Main Page | Namespace List | Class Hierarchy | Data Structures | File List | Data Fields | Globals | Related Pages

soapC.cpp

Go to the documentation of this file.
00001 /* soapC.cpp
00002    Generated by gSOAP 2.7.8c from acq2xx.h
00003    Copyright (C) 2000-2006, Robert van Engelen, Genivia Inc. All Rights Reserved.
00004    This part of the software is released under one of the following licenses:
00005    GPL, the gSOAP public license, or Genivia's license for commercial use.
00006 */
00007 
00008 #include "soapH.h"
00009 
00010 SOAP_SOURCE_STAMP("@(#) soapC.cpp ver 2.7.8c 2006-08-21 11:13:38 GMT")
00011 
00012 
00013 #ifndef WITH_NOGLOBAL
00014 
00015 SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
00016 {
00017         if (soap->header)
00018                 soap_serialize_SOAP_ENV__Header(soap, soap->header);
00019 }
00020 
00021 SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
00022 {
00023         if (soap->header)
00024         {       soap->part = SOAP_IN_HEADER;
00025                 soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL);
00026                 soap->part = SOAP_END_HEADER;
00027         }
00028         return SOAP_OK;
00029 }
00030 
00031 SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
00032 {
00033         soap->part = SOAP_IN_HEADER;
00034         soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
00035         soap->part = SOAP_END_HEADER;
00036         return soap->header == NULL;
00037 }
00038 
00039 SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)
00040 {
00041         if (!soap->fault)
00042         {       soap->fault = (struct SOAP_ENV__Fault*)soap_malloc(soap, sizeof(struct SOAP_ENV__Fault));
00043                 soap_default_SOAP_ENV__Fault(soap, soap->fault);
00044         }
00045         if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)
00046         {       soap->fault->SOAP_ENV__Code = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00047                 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);
00048         }
00049         if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)
00050         {       soap->fault->SOAP_ENV__Reason = (struct SOAP_ENV__Reason*)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason));
00051                 soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);
00052         }
00053 }
00054 
00055 SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
00056 {
00057         if (soap->fault)
00058                 soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
00059 }
00060 
00061 SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
00062 {
00063         if (soap->fault)
00064                 return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL);
00065         return SOAP_OK;
00066 }
00067 
00068 SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
00069 {
00070         return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
00071 }
00072 
00073 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
00074 {
00075         soap_fault(soap);
00076         if (soap->version == 2)
00077                 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
00078         return (const char**)&soap->fault->faultcode;
00079 }
00080 
00081 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
00082 {
00083         soap_fault(soap);
00084         if (soap->version == 2)
00085         {       if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)
00086                 {       soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = (struct SOAP_ENV__Code*)soap_malloc(soap, sizeof(struct SOAP_ENV__Code));
00087                         soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);
00088                 }
00089                 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
00090         }
00091         return (const char**)&soap->fault->faultcode;
00092 }
00093 
00094 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
00095 {
00096         soap_fault(soap);
00097         if (soap->version == 2)
00098                 return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
00099         return (const char**)&soap->fault->faultstring;
00100 }
00101 
00102 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
00103 {
00104         soap_fault(soap);
00105         if (soap->version == 1)
00106         {       if (!soap->fault->detail)
00107                 {       soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00108                         soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);
00109                 }
00110                 return (const char**)&soap->fault->detail->__any;
00111         }
00112         if (!soap->fault->SOAP_ENV__Detail)
00113         {       soap->fault->SOAP_ENV__Detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
00114                 soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);
00115         }
00116         return (const char**)&soap->fault->SOAP_ENV__Detail->__any;
00117 }
00118 
00119 #endif
00120 
00121 #ifndef WITH_NOIDREF
00122 SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)
00123 {
00124         int t;
00125         for (;;)
00126                 if (!soap_getelement(soap, &t))
00127                         if (soap->error || soap_ignore_element(soap))
00128                                 break;
00129         if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
00130                 soap->error = SOAP_OK;
00131         return soap->error;
00132 }
00133 #endif
00134 
00135 #ifndef WITH_NOIDREF
00136 SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type)
00137 {
00138         if (soap_peek_element(soap))
00139                 return NULL;
00140         if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))
00141                 *type = soap_lookup_type(soap, soap->href);
00142         switch (*type)
00143         {
00144         case SOAP_TYPE_byte:
00145                 return soap_in_byte(soap, NULL, NULL, "xsd:byte");
00146         case SOAP_TYPE_int:
00147                 return soap_in_int(soap, NULL, NULL, "xsd:int");
00148         case SOAP_TYPE_float:
00149                 return soap_in_float(soap, NULL, NULL, "xsd:float");
00150         case SOAP_TYPE_acq2xx__MODE:
00151                 return soap_in_acq2xx__MODE(soap, NULL, NULL, "acq2xx:MODE");
00152         case SOAP_TYPE_acq2xx__DOx:
00153                 return soap_in_acq2xx__DOx(soap, NULL, NULL, "acq2xx:DOx");
00154         case SOAP_TYPE_acq2xx__DIx:
00155                 return soap_in_acq2xx__DIx(soap, NULL, NULL, "acq2xx:DIx");
00156         case SOAP_TYPE_acq2xx__EDGE:
00157                 return soap_in_acq2xx__EDGE(soap, NULL, NULL, "acq2xx:EDGE");
00158         case SOAP_TYPE_bool:
00159                 return soap_in_bool(soap, NULL, NULL, "xsd:boolean");
00160         case SOAP_TYPE_STATE:
00161                 return soap_in_STATE(soap, NULL, NULL, "STATE");
00162         case SOAP_TYPE_acq2xx__GetVRangeTransaction:
00163                 return soap_in_acq2xx__GetVRangeTransaction(soap, NULL, NULL, "acq2xx:GetVRangeTransaction");
00164         case SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction:
00165                 return soap_in_acq2xx__GetAvailableChannelsTransaction(soap, NULL, NULL, "acq2xx:GetAvailableChannelsTransaction");
00166         case SOAP_TYPE_acq2xx__AcqControlTransaction:
00167                 return soap_in_acq2xx__AcqControlTransaction(soap, NULL, NULL, "acq2xx:AcqControlTransaction");
00168         case SOAP_TYPE_acq2xx__SignalSetTransaction:
00169                 return soap_in_acq2xx__SignalSetTransaction(soap, NULL, NULL, "acq2xx:SignalSetTransaction");
00170         case SOAP_TYPE_acq2xx__ExternalClockSetTransaction:
00171                 return soap_in_acq2xx__ExternalClockSetTransaction(soap, NULL, NULL, "acq2xx:ExternalClockSetTransaction");
00172         case SOAP_TYPE_acq2xx__InternalClockSetTransaction:
00173                 return soap_in_acq2xx__InternalClockSetTransaction(soap, NULL, NULL, "acq2xx:InternalClockSetTransaction");
00174         case SOAP_TYPE_acq2xx__ClockSetTransaction:
00175                 return soap_in_acq2xx__ClockSetTransaction(soap, NULL, NULL, "acq2xx:ClockSetTransaction");
00176         case SOAP_TYPE_acq2xx__ModeSetTransaction:
00177                 return soap_in_acq2xx__ModeSetTransaction(soap, NULL, NULL, "acq2xx:ModeSetTransaction");
00178         case SOAP_TYPE_acq2xx__ShellTransaction:
00179                 return soap_in_acq2xx__ShellTransaction(soap, NULL, NULL, "acq2xx:ShellTransaction");
00180         case SOAP_TYPE_acq2xx__TransactionList:
00181                 return soap_in_acq2xx__TransactionList(soap, NULL, NULL, "acq2xx:TransactionList");
00182         case SOAP_TYPE_acq2xx__Transaction:
00183                 return soap_in_acq2xx__Transaction(soap, NULL, NULL, "acq2xx:Transaction");
00184         case SOAP_TYPE_acq2xx__Object:
00185                 return soap_in_acq2xx__Object(soap, NULL, NULL, "acq2xx:Object");
00186         case SOAP_TYPE_VRangeData:
00187                 return soap_in_VRangeData(soap, NULL, NULL, "VRange");
00188         case SOAP_TYPE_VRange:
00189                 return soap_in_VRange(soap, NULL, NULL, "VRange");
00190         case SOAP_TYPE_acq2xx__Signal:
00191                 return soap_in_acq2xx__Signal(soap, NULL, NULL, "acq2xx:Signal");
00192         case SOAP_TYPE_acq2xx__waitStop:
00193                 return soap_in_acq2xx__waitStop(soap, NULL, NULL, "acq2xx:waitStop");
00194         case SOAP_TYPE_acq2xx__setArm:
00195                 return soap_in_acq2xx__setArm(soap, NULL, NULL, "acq2xx:setArm");
00196         case SOAP_TYPE_acq2xx__getAcqStatus:
00197                 return soap_in_acq2xx__getAcqStatus(soap, NULL, NULL, "acq2xx:getAcqStatus");
00198         case SOAP_TYPE_acq2xx__AcqStatus:
00199                 return soap_in_acq2xx__AcqStatus(soap, NULL, NULL, "acq2xx:AcqStatus");
00200         case SOAP_TYPE_acq2xx__acq2script:
00201                 return soap_in_acq2xx__acq2script(soap, NULL, NULL, "acq2xx:acq2script");
00202         case SOAP_TYPE_acq2xx__acq2scriptResponse:
00203                 return soap_in_acq2xx__acq2scriptResponse(soap, NULL, NULL, "acq2xx:acq2scriptResponse");
00204         case SOAP_TYPE_acq2xx__acq2sh:
00205                 return soap_in_acq2xx__acq2sh(soap, NULL, NULL, "acq2xx:acq2sh");
00206         case SOAP_TYPE_acq2xx__acq2shResponse:
00207                 return soap_in_acq2xx__acq2shResponse(soap, NULL, NULL, "acq2xx:acq2shResponse");
00208         case SOAP_TYPE_acq2xx__acqcmd:
00209                 return soap_in_acq2xx__acqcmd(soap, NULL, NULL, "acq2xx:acqcmd");
00210         case SOAP_TYPE_acq2xx__acqcmdResponse:
00211                 return soap_in_acq2xx__acqcmdResponse(soap, NULL, NULL, "acq2xx:acqcmdResponse");
00212         case SOAP_TYPE_acq2xx__getVersion:
00213                 return soap_in_acq2xx__getVersion(soap, NULL, NULL, "acq2xx:getVersion");
00214         case SOAP_TYPE_acq2xx__getVersionResponse:
00215                 return soap_in_acq2xx__getVersionResponse(soap, NULL, NULL, "acq2xx:getVersionResponse");
00216         case SOAP_TYPE_PointerToVRange:
00217                 return soap_in_PointerToVRange(soap, NULL, NULL, "VRange");
00218         case SOAP_TYPE_PointerToacq2xx__GetAvailableChannelsTransaction:
00219                 return soap_in_PointerToacq2xx__GetAvailableChannelsTransaction(soap, NULL, NULL, "acq2xx:GetAvailableChannelsTransaction");
00220         case SOAP_TYPE_PointerToPointerToacq2xx__Transaction:
00221                 return soap_in_PointerToPointerToacq2xx__Transaction(soap, NULL, NULL, "acq2xx:Transaction");
00222         case SOAP_TYPE_PointerToacq2xx__Transaction:
00223                 return soap_in_PointerToacq2xx__Transaction(soap, NULL, NULL, "acq2xx:Transaction");
00224         case SOAP_TYPE_string:
00225         {       char **s;
00226                 s = soap_in_string(soap, NULL, NULL, "xsd:string");
00227                 return s ? *s : NULL;
00228         }
00229         default:
00230         {       const char *t = soap->type;
00231                 if (!*t)
00232                         t = soap->tag;
00233                 if (!soap_match_tag(soap, t, "xsd:byte"))
00234                 {       *type = SOAP_TYPE_byte;
00235                         return soap_in_byte(soap, NULL, NULL, NULL);
00236                 }
00237                 if (!soap_match_tag(soap, t, "xsd:int"))
00238                 {       *type = SOAP_TYPE_int;
00239                         return soap_in_int(soap, NULL, NULL, NULL);
00240                 }
00241                 if (!soap_match_tag(soap, t, "xsd:float"))
00242                 {       *type = SOAP_TYPE_float;
00243                         return soap_in_float(soap, NULL, NULL, NULL);
00244                 }
00245                 if (!soap_match_tag(soap, t, "acq2xx:MODE"))
00246                 {       *type = SOAP_TYPE_acq2xx__MODE;
00247                         return soap_in_acq2xx__MODE(soap, NULL, NULL, NULL);
00248                 }
00249                 if (!soap_match_tag(soap, t, "acq2xx:DOx"))
00250                 {       *type = SOAP_TYPE_acq2xx__DOx;
00251                         return soap_in_acq2xx__DOx(soap, NULL, NULL, NULL);
00252                 }
00253                 if (!soap_match_tag(soap, t, "acq2xx:DIx"))
00254                 {       *type = SOAP_TYPE_acq2xx__DIx;
00255                         return soap_in_acq2xx__DIx(soap, NULL, NULL, NULL);
00256                 }
00257                 if (!soap_match_tag(soap, t, "acq2xx:EDGE"))
00258                 {       *type = SOAP_TYPE_acq2xx__EDGE;
00259                         return soap_in_acq2xx__EDGE(soap, NULL, NULL, NULL);
00260                 }
00261                 if (!soap_match_tag(soap, t, "xsd:boolean"))
00262                 {       *type = SOAP_TYPE_bool;
00263                         return soap_in_bool(soap, NULL, NULL, NULL);
00264                 }
00265                 if (!soap_match_tag(soap, t, "STATE"))
00266                 {       *type = SOAP_TYPE_STATE;
00267                         return soap_in_STATE(soap, NULL, NULL, NULL);
00268                 }
00269                 if (!soap_match_tag(soap, t, "acq2xx:GetVRangeTransaction"))
00270                 {       *type = SOAP_TYPE_acq2xx__GetVRangeTransaction;
00271                         return soap_in_acq2xx__GetVRangeTransaction(soap, NULL, NULL, NULL);
00272                 }
00273                 if (!soap_match_tag(soap, t, "acq2xx:GetAvailableChannelsTransaction"))
00274                 {       *type = SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction;
00275                         return soap_in_acq2xx__GetAvailableChannelsTransaction(soap, NULL, NULL, NULL);
00276                 }
00277                 if (!soap_match_tag(soap, t, "acq2xx:AcqControlTransaction"))
00278                 {       *type = SOAP_TYPE_acq2xx__AcqControlTransaction;
00279                         return soap_in_acq2xx__AcqControlTransaction(soap, NULL, NULL, NULL);
00280                 }
00281                 if (!soap_match_tag(soap, t, "acq2xx:SignalSetTransaction"))
00282                 {       *type = SOAP_TYPE_acq2xx__SignalSetTransaction;
00283                         return soap_in_acq2xx__SignalSetTransaction(soap, NULL, NULL, NULL);
00284                 }
00285                 if (!soap_match_tag(soap, t, "acq2xx:ExternalClockSetTransaction"))
00286                 {       *type = SOAP_TYPE_acq2xx__ExternalClockSetTransaction;
00287                         return soap_in_acq2xx__ExternalClockSetTransaction(soap, NULL, NULL, NULL);
00288                 }
00289                 if (!soap_match_tag(soap, t, "acq2xx:InternalClockSetTransaction"))
00290                 {       *type = SOAP_TYPE_acq2xx__InternalClockSetTransaction;
00291                         return soap_in_acq2xx__InternalClockSetTransaction(soap, NULL, NULL, NULL);
00292                 }
00293                 if (!soap_match_tag(soap, t, "acq2xx:ClockSetTransaction"))
00294                 {       *type = SOAP_TYPE_acq2xx__ClockSetTransaction;
00295                         return soap_in_acq2xx__ClockSetTransaction(soap, NULL, NULL, NULL);
00296                 }
00297                 if (!soap_match_tag(soap, t, "acq2xx:ModeSetTransaction"))
00298                 {       *type = SOAP_TYPE_acq2xx__ModeSetTransaction;
00299                         return soap_in_acq2xx__ModeSetTransaction(soap, NULL, NULL, NULL);
00300                 }
00301                 if (!soap_match_tag(soap, t, "acq2xx:ShellTransaction"))
00302                 {       *type = SOAP_TYPE_acq2xx__ShellTransaction;
00303                         return soap_in_acq2xx__ShellTransaction(soap, NULL, NULL, NULL);
00304                 }
00305                 if (!soap_match_tag(soap, t, "acq2xx:TransactionList"))
00306                 {       *type = SOAP_TYPE_acq2xx__TransactionList;
00307                         return soap_in_acq2xx__TransactionList(soap, NULL, NULL, NULL);
00308                 }
00309                 if (!soap_match_tag(soap, t, "acq2xx:Transaction"))
00310                 {       *type = SOAP_TYPE_acq2xx__Transaction;
00311                         return soap_in_acq2xx__Transaction(soap, NULL, NULL, NULL);
00312                 }
00313                 if (!soap_match_tag(soap, t, "acq2xx:Object"))
00314                 {       *type = SOAP_TYPE_acq2xx__Object;
00315                         return soap_in_acq2xx__Object(soap, NULL, NULL, NULL);
00316                 }
00317                 if (*soap->arrayType && !soap_match_array(soap, "VRange"))
00318                 {       *type = SOAP_TYPE_VRangeData;
00319                         return soap_in_VRangeData(soap, NULL, NULL, NULL);
00320                 }
00321                 if (!soap_match_tag(soap, t, "VRange"))
00322                 {       *type = SOAP_TYPE_VRange;
00323                         return soap_in_VRange(soap, NULL, NULL, NULL);
00324                 }
00325                 if (!soap_match_tag(soap, t, "acq2xx:Signal"))
00326                 {       *type = SOAP_TYPE_acq2xx__Signal;
00327                         return soap_in_acq2xx__Signal(soap, NULL, NULL, NULL);
00328                 }
00329                 if (!soap_match_tag(soap, t, "acq2xx:waitStop"))
00330                 {       *type = SOAP_TYPE_acq2xx__waitStop;
00331                         return soap_in_acq2xx__waitStop(soap, NULL, NULL, NULL);
00332                 }
00333                 if (!soap_match_tag(soap, t, "acq2xx:setArm"))
00334                 {       *type = SOAP_TYPE_acq2xx__setArm;
00335                         return soap_in_acq2xx__setArm(soap, NULL, NULL, NULL);
00336                 }
00337                 if (!soap_match_tag(soap, t, "acq2xx:getAcqStatus"))
00338                 {       *type = SOAP_TYPE_acq2xx__getAcqStatus;
00339                         return soap_in_acq2xx__getAcqStatus(soap, NULL, NULL, NULL);
00340                 }
00341                 if (!soap_match_tag(soap, t, "acq2xx:AcqStatus"))
00342                 {       *type = SOAP_TYPE_acq2xx__AcqStatus;
00343                         return soap_in_acq2xx__AcqStatus(soap, NULL, NULL, NULL);
00344                 }
00345                 if (!soap_match_tag(soap, t, "acq2xx:acq2script"))
00346                 {       *type = SOAP_TYPE_acq2xx__acq2script;
00347                         return soap_in_acq2xx__acq2script(soap, NULL, NULL, NULL);
00348                 }
00349                 if (!soap_match_tag(soap, t, "acq2xx:acq2scriptResponse"))
00350                 {       *type = SOAP_TYPE_acq2xx__acq2scriptResponse;
00351                         return soap_in_acq2xx__acq2scriptResponse(soap, NULL, NULL, NULL);
00352                 }
00353                 if (!soap_match_tag(soap, t, "acq2xx:acq2sh"))
00354                 {       *type = SOAP_TYPE_acq2xx__acq2sh;
00355                         return soap_in_acq2xx__acq2sh(soap, NULL, NULL, NULL);
00356                 }
00357                 if (!soap_match_tag(soap, t, "acq2xx:acq2shResponse"))
00358                 {       *type = SOAP_TYPE_acq2xx__acq2shResponse;
00359                         return soap_in_acq2xx__acq2shResponse(soap, NULL, NULL, NULL);
00360                 }
00361                 if (!soap_match_tag(soap, t, "acq2xx:acqcmd"))
00362                 {       *type = SOAP_TYPE_acq2xx__acqcmd;
00363                         return soap_in_acq2xx__acqcmd(soap, NULL, NULL, NULL);
00364                 }
00365                 if (!soap_match_tag(soap, t, "acq2xx:acqcmdResponse"))
00366                 {       *type = SOAP_TYPE_acq2xx__acqcmdResponse;
00367                         return soap_in_acq2xx__acqcmdResponse(soap, NULL, NULL, NULL);
00368                 }
00369                 if (!soap_match_tag(soap, t, "acq2xx:getVersion"))
00370                 {       *type = SOAP_TYPE_acq2xx__getVersion;
00371                         return soap_in_acq2xx__getVersion(soap, NULL, NULL, NULL);
00372                 }
00373                 if (!soap_match_tag(soap, t, "acq2xx:getVersionResponse"))
00374                 {       *type = SOAP_TYPE_acq2xx__getVersionResponse;
00375                         return soap_in_acq2xx__getVersionResponse(soap, NULL, NULL, NULL);
00376                 }
00377                 if (!soap_match_tag(soap, t, "xsd:string"))
00378                 {       char **s;
00379                         *type = SOAP_TYPE_string;
00380                         s = soap_in_string(soap, NULL, NULL, NULL);
00381                         return s ? *s : NULL;
00382                 }
00383                 if (!soap_match_tag(soap, t, "xsd:string"))
00384                 {       char **s;
00385                         *type = SOAP_TYPE_string;
00386                         s = soap_in_string(soap, NULL, NULL, NULL);
00387                         return s ? *s : NULL;
00388                 }
00389                 t = soap->tag;
00390                 if (!soap_match_tag(soap, t, "QName"))
00391                 {       char **s;
00392                         *type = SOAP_TYPE__QName;
00393                         s = soap_in__QName(soap, NULL, NULL, NULL);
00394                         return s ? *s : NULL;
00395                 }
00396         }
00397         }
00398         soap->error = SOAP_TAG_MISMATCH;
00399         return NULL;
00400 }
00401 #endif
00402 
00403 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
00404 {
00405         if (!soap_peek_element(soap))
00406         {       int t;
00407                 if (soap->mustUnderstand && !soap->other)
00408                         return soap->error = SOAP_MUSTUNDERSTAND;
00409                 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
00410                 {       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
00411                         return soap->error = SOAP_TAG_MISMATCH;
00412                 }
00413                 if (!*soap->id || !soap_getelement(soap, &t))
00414                 {       soap->peeked = 0;
00415                         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unknown element '%s' (level=%u, %d)\n", soap->tag, soap->level, soap->body));
00416                         if (soap->fignore)
00417                                 soap->error = soap->fignore(soap, soap->tag);
00418                         else
00419                                 soap->error = SOAP_OK;
00420                         DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
00421                         if (!soap->error && soap->body)
00422                         {       soap->level++;
00423                                 while (!soap_ignore_element(soap))
00424                                         ;
00425                                 if (soap->error == SOAP_NO_TAG)
00426                                         soap->error = soap_element_end_in(soap, NULL);
00427                         }
00428                 }
00429         }
00430         return soap->error;
00431 }
00432 
00433 #ifndef WITH_NOIDREF
00434 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
00435 {
00436         int i;
00437         struct soap_plist *pp;
00438         if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
00439                 for (i = 0; i < SOAP_PTRHASH; i++)
00440                         for (pp = soap->pht[i]; pp; pp = pp->next)
00441                                 if (pp->mark1 == 2 || pp->mark2 == 2)
00442                                         if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
00443                                                 return soap->error;
00444         return SOAP_OK;
00445 }
00446 #endif
00447 
00448 #ifndef WITH_NOIDREF
00449 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
00450 {
00451         switch (type)
00452         {
00453         case SOAP_TYPE_byte:
00454                 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
00455         case SOAP_TYPE_int:
00456                 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
00457         case SOAP_TYPE_float:
00458                 return soap_out_float(soap, tag, id, (const float *)ptr, "xsd:float");
00459         case SOAP_TYPE_acq2xx__MODE:
00460                 return soap_out_acq2xx__MODE(soap, tag, id, (const enum acq2xx__MODE *)ptr, "acq2xx:MODE");
00461         case SOAP_TYPE_acq2xx__DOx:
00462                 return soap_out_acq2xx__DOx(soap, tag, id, (const enum acq2xx__DOx *)ptr, "acq2xx:DOx");
00463         case SOAP_TYPE_acq2xx__DIx:
00464                 return soap_out_acq2xx__DIx(soap, tag, id, (const enum acq2xx__DIx *)ptr, "acq2xx:DIx");
00465         case SOAP_TYPE_acq2xx__EDGE:
00466                 return soap_out_acq2xx__EDGE(soap, tag, id, (const enum acq2xx__EDGE *)ptr, "acq2xx:EDGE");
00467         case SOAP_TYPE_bool:
00468                 return soap_out_bool(soap, tag, id, (const bool *)ptr, "xsd:boolean");
00469         case SOAP_TYPE_STATE:
00470                 return soap_out_STATE(soap, tag, id, (const enum STATE *)ptr, "STATE");
00471         case SOAP_TYPE_acq2xx__GetVRangeTransaction:
00472                 return ((acq2xx__GetVRangeTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:GetVRangeTransaction");
00473         case SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction:
00474                 return ((acq2xx__GetAvailableChannelsTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:GetAvailableChannelsTransaction");
00475         case SOAP_TYPE_acq2xx__AcqControlTransaction:
00476                 return ((acq2xx__AcqControlTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:AcqControlTransaction");
00477         case SOAP_TYPE_acq2xx__SignalSetTransaction:
00478                 return ((acq2xx__SignalSetTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:SignalSetTransaction");
00479         case SOAP_TYPE_acq2xx__ExternalClockSetTransaction:
00480                 return ((acq2xx__ExternalClockSetTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:ExternalClockSetTransaction");
00481         case SOAP_TYPE_acq2xx__InternalClockSetTransaction:
00482                 return ((acq2xx__InternalClockSetTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:InternalClockSetTransaction");
00483         case SOAP_TYPE_acq2xx__ClockSetTransaction:
00484                 return ((acq2xx__ClockSetTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:ClockSetTransaction");
00485         case SOAP_TYPE_acq2xx__ModeSetTransaction:
00486                 return ((acq2xx__ModeSetTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:ModeSetTransaction");
00487         case SOAP_TYPE_acq2xx__ShellTransaction:
00488                 return ((acq2xx__ShellTransaction *)ptr)->soap_out(soap, tag, id, "acq2xx:ShellTransaction");
00489         case SOAP_TYPE_acq2xx__TransactionList:
00490                 return ((acq2xx__TransactionList *)ptr)->soap_out(soap, tag, id, "acq2xx:TransactionList");
00491         case SOAP_TYPE_acq2xx__Transaction:
00492                 return ((acq2xx__Transaction *)ptr)->soap_out(soap, tag, id, "acq2xx:Transaction");
00493         case SOAP_TYPE_acq2xx__Object:
00494                 return ((acq2xx__Object *)ptr)->soap_out(soap, tag, id, "acq2xx:Object");
00495         case SOAP_TYPE_VRangeData:
00496                 return soap_out_VRangeData(soap, tag, id, (const struct VRangeData *)ptr, "VRange");
00497         case SOAP_TYPE_VRange:
00498                 return soap_out_VRange(soap, tag, id, (const struct VRange *)ptr, "VRange");
00499         case SOAP_TYPE_acq2xx__Signal:
00500                 return soap_out_acq2xx__Signal(soap, tag, id, (const struct acq2xx__Signal *)ptr, "acq2xx:Signal");
00501         case SOAP_TYPE_acq2xx__waitStop:
00502                 return soap_out_acq2xx__waitStop(soap, tag, id, (const struct acq2xx__waitStop *)ptr, "acq2xx:waitStop");
00503         case SOAP_TYPE_acq2xx__setArm:
00504                 return soap_out_acq2xx__setArm(soap, tag, id, (const struct acq2xx__setArm *)ptr, "acq2xx:setArm");
00505         case SOAP_TYPE_acq2xx__getAcqStatus:
00506                 return soap_out_acq2xx__getAcqStatus(soap, tag, id, (const struct acq2xx__getAcqStatus *)ptr, "acq2xx:getAcqStatus");
00507         case SOAP_TYPE_acq2xx__AcqStatus:
00508                 return soap_out_acq2xx__AcqStatus(soap, tag, id, (const struct acq2xx__AcqStatus *)ptr, "acq2xx:AcqStatus");
00509         case SOAP_TYPE_acq2xx__acq2script:
00510                 return soap_out_acq2xx__acq2script(soap, tag, id, (const struct acq2xx__acq2script *)ptr, "acq2xx:acq2script");
00511         case SOAP_TYPE_acq2xx__acq2scriptResponse:
00512                 return soap_out_acq2xx__acq2scriptResponse(soap, tag, id, (const struct acq2xx__acq2scriptResponse *)ptr, "acq2xx:acq2scriptResponse");
00513         case SOAP_TYPE_acq2xx__acq2sh:
00514                 return soap_out_acq2xx__acq2sh(soap, tag, id, (const struct acq2xx__acq2sh *)ptr, "acq2xx:acq2sh");
00515         case SOAP_TYPE_acq2xx__acq2shResponse:
00516                 return soap_out_acq2xx__acq2shResponse(soap, tag, id, (const struct acq2xx__acq2shResponse *)ptr, "acq2xx:acq2shResponse");
00517         case SOAP_TYPE_acq2xx__acqcmd:
00518                 return soap_out_acq2xx__acqcmd(soap, tag, id, (const struct acq2xx__acqcmd *)ptr, "acq2xx:acqcmd");
00519         case SOAP_TYPE_acq2xx__acqcmdResponse:
00520                 return soap_out_acq2xx__acqcmdResponse(soap, tag, id, (const struct acq2xx__acqcmdResponse *)ptr, "acq2xx:acqcmdResponse");
00521         case SOAP_TYPE_acq2xx__getVersion:
00522                 return soap_out_acq2xx__getVersion(soap, tag, id, (const struct acq2xx__getVersion *)ptr, "acq2xx:getVersion");
00523         case SOAP_TYPE_acq2xx__getVersionResponse:
00524                 return soap_out_acq2xx__getVersionResponse(soap, tag, id, (const struct acq2xx__getVersionResponse *)ptr, "acq2xx:getVersionResponse");
00525         case SOAP_TYPE_PointerToVRange:
00526                 return soap_out_PointerToVRange(soap, tag, id, (struct VRange *const*)ptr, "VRange");
00527         case SOAP_TYPE_PointerToacq2xx__GetAvailableChannelsTransaction:
00528                 return soap_out_PointerToacq2xx__GetAvailableChannelsTransaction(soap, tag, id, (acq2xx__GetAvailableChannelsTransaction *const*)ptr, "acq2xx:GetAvailableChannelsTransaction");
00529         case SOAP_TYPE_PointerToPointerToacq2xx__Transaction:
00530                 return soap_out_PointerToPointerToacq2xx__Transaction(soap, tag, id, (acq2xx__Transaction **const*)ptr, "acq2xx:Transaction");
00531         case SOAP_TYPE_PointerToacq2xx__Transaction:
00532                 return soap_out_PointerToacq2xx__Transaction(soap, tag, id, (acq2xx__Transaction *const*)ptr, "acq2xx:Transaction");
00533         case SOAP_TYPE__QName:
00534                 return soap_out_string(soap, "QName", id, (char**)&ptr, NULL);
00535         case SOAP_TYPE_string:
00536                 return soap_out_string(soap, tag, id, (char**)&ptr, "xsd:string");
00537         }
00538         return SOAP_OK;
00539 }
00540 #endif
00541 
00542 #ifndef WITH_NOIDREF
00543 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
00544 {
00545         (void)soap; (void)ptr; (void)type; /* appease -Wall -Werror */
00546         switch (type)
00547         {
00548         case SOAP_TYPE_acq2xx__GetVRangeTransaction:
00549                 ((acq2xx__GetVRangeTransaction *)ptr)->soap_serialize(soap);
00550                 break;
00551         case SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction:
00552                 ((acq2xx__GetAvailableChannelsTransaction *)ptr)->soap_serialize(soap);
00553                 break;
00554         case SOAP_TYPE_acq2xx__AcqControlTransaction:
00555                 ((acq2xx__AcqControlTransaction *)ptr)->soap_serialize(soap);
00556                 break;
00557         case SOAP_TYPE_acq2xx__SignalSetTransaction:
00558                 ((acq2xx__SignalSetTransaction *)ptr)->soap_serialize(soap);
00559                 break;
00560         case SOAP_TYPE_acq2xx__ExternalClockSetTransaction:
00561                 ((acq2xx__ExternalClockSetTransaction *)ptr)->soap_serialize(soap);
00562                 break;
00563         case SOAP_TYPE_acq2xx__InternalClockSetTransaction:
00564                 ((acq2xx__InternalClockSetTransaction *)ptr)->soap_serialize(soap);
00565                 break;
00566         case SOAP_TYPE_acq2xx__ClockSetTransaction:
00567                 ((acq2xx__ClockSetTransaction *)ptr)->soap_serialize(soap);
00568                 break;
00569         case SOAP_TYPE_acq2xx__ModeSetTransaction:
00570                 ((acq2xx__ModeSetTransaction *)ptr)->soap_serialize(soap);
00571                 break;
00572         case SOAP_TYPE_acq2xx__ShellTransaction:
00573                 ((acq2xx__ShellTransaction *)ptr)->soap_serialize(soap);
00574                 break;
00575         case SOAP_TYPE_acq2xx__TransactionList:
00576                 ((acq2xx__TransactionList *)ptr)->soap_serialize(soap);
00577                 break;
00578         case SOAP_TYPE_acq2xx__Transaction:
00579                 ((acq2xx__Transaction *)ptr)->soap_serialize(soap);
00580                 break;
00581         case SOAP_TYPE_acq2xx__Object:
00582                 ((acq2xx__Object *)ptr)->soap_serialize(soap);
00583                 break;
00584         case SOAP_TYPE_VRangeData:
00585                 soap_serialize_VRangeData(soap, (const struct VRangeData *)ptr);
00586                 break;
00587         case SOAP_TYPE_VRange:
00588                 soap_serialize_VRange(soap, (const struct VRange *)ptr);
00589                 break;
00590         case SOAP_TYPE_acq2xx__Signal:
00591                 soap_serialize_acq2xx__Signal(soap, (const struct acq2xx__Signal *)ptr);
00592                 break;
00593         case SOAP_TYPE_acq2xx__waitStop:
00594                 soap_serialize_acq2xx__waitStop(soap, (const struct acq2xx__waitStop *)ptr);
00595                 break;
00596         case SOAP_TYPE_acq2xx__setArm:
00597                 soap_serialize_acq2xx__setArm(soap, (const struct acq2xx__setArm *)ptr);
00598                 break;
00599         case SOAP_TYPE_acq2xx__getAcqStatus:
00600                 soap_serialize_acq2xx__getAcqStatus(soap, (const struct acq2xx__getAcqStatus *)ptr);
00601                 break;
00602         case SOAP_TYPE_acq2xx__AcqStatus:
00603                 soap_serialize_acq2xx__AcqStatus(soap, (const struct acq2xx__AcqStatus *)ptr);
00604                 break;
00605         case SOAP_TYPE_acq2xx__acq2script:
00606                 soap_serialize_acq2xx__acq2script(soap, (const struct acq2xx__acq2script *)ptr);
00607                 break;
00608         case SOAP_TYPE_acq2xx__acq2scriptResponse:
00609                 soap_serialize_acq2xx__acq2scriptResponse(soap, (const struct acq2xx__acq2scriptResponse *)ptr);
00610                 break;
00611         case SOAP_TYPE_acq2xx__acq2sh:
00612                 soap_serialize_acq2xx__acq2sh(soap, (const struct acq2xx__acq2sh *)ptr);
00613                 break;
00614         case SOAP_TYPE_acq2xx__acq2shResponse:
00615                 soap_serialize_acq2xx__acq2shResponse(soap, (const struct acq2xx__acq2shResponse *)ptr);
00616                 break;
00617         case SOAP_TYPE_acq2xx__acqcmd:
00618                 soap_serialize_acq2xx__acqcmd(soap, (const struct acq2xx__acqcmd *)ptr);
00619                 break;
00620         case SOAP_TYPE_acq2xx__acqcmdResponse:
00621                 soap_serialize_acq2xx__acqcmdResponse(soap, (const struct acq2xx__acqcmdResponse *)ptr);
00622                 break;
00623         case SOAP_TYPE_acq2xx__getVersion:
00624                 soap_serialize_acq2xx__getVersion(soap, (const struct acq2xx__getVersion *)ptr);
00625                 break;
00626         case SOAP_TYPE_acq2xx__getVersionResponse:
00627                 soap_serialize_acq2xx__getVersionResponse(soap, (const struct acq2xx__getVersionResponse *)ptr);
00628                 break;
00629         case SOAP_TYPE_PointerToVRange:
00630                 soap_serialize_PointerToVRange(soap, (struct VRange *const*)ptr);
00631                 break;
00632         case SOAP_TYPE_PointerToacq2xx__GetAvailableChannelsTransaction:
00633                 soap_serialize_PointerToacq2xx__GetAvailableChannelsTransaction(soap, (acq2xx__GetAvailableChannelsTransaction *const*)ptr);
00634                 break;
00635         case SOAP_TYPE_PointerToPointerToacq2xx__Transaction:
00636                 soap_serialize_PointerToPointerToacq2xx__Transaction(soap, (acq2xx__Transaction **const*)ptr);
00637                 break;
00638         case SOAP_TYPE_PointerToacq2xx__Transaction:
00639                 soap_serialize_PointerToacq2xx__Transaction(soap, (acq2xx__Transaction *const*)ptr);
00640                 break;
00641         case SOAP_TYPE__QName:
00642                 soap_serialize_string(soap, (char**)&ptr);
00643                 break;
00644         case SOAP_TYPE_string:
00645                 soap_serialize_string(soap, (char**)&ptr);
00646                 break;
00647         }
00648 }
00649 #endif
00650 
00651 SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap *soap, int t, const char *type, const char *arrayType, size_t *n)
00652 {
00653         switch (t)
00654         {
00655         case SOAP_TYPE_acq2xx__getVersionResponse:
00656                 return (void*)soap_instantiate_acq2xx__getVersionResponse(soap, -1, type, arrayType, n);
00657         case SOAP_TYPE_acq2xx__getVersion:
00658                 return (void*)soap_instantiate_acq2xx__getVersion(soap, -1, type, arrayType, n);
00659         case SOAP_TYPE_acq2xx__acqcmdResponse:
00660                 return (void*)soap_instantiate_acq2xx__acqcmdResponse(soap, -1, type, arrayType, n);
00661         case SOAP_TYPE_acq2xx__acqcmd:
00662                 return (void*)soap_instantiate_acq2xx__acqcmd(soap, -1, type, arrayType, n);
00663         case SOAP_TYPE_acq2xx__acq2shResponse:
00664                 return (void*)soap_instantiate_acq2xx__acq2shResponse(soap, -1, type, arrayType, n);
00665         case SOAP_TYPE_acq2xx__acq2sh:
00666                 return (void*)soap_instantiate_acq2xx__acq2sh(soap, -1, type, arrayType, n);
00667         case SOAP_TYPE_acq2xx__Object:
00668                 return (void*)soap_instantiate_acq2xx__Object(soap, -1, type, arrayType, n);
00669         case SOAP_TYPE_acq2xx__Transaction:
00670                 return (void*)soap_instantiate_acq2xx__Transaction(soap, -1, type, arrayType, n);
00671         case SOAP_TYPE_acq2xx__TransactionList:
00672                 return (void*)soap_instantiate_acq2xx__TransactionList(soap, -1, type, arrayType, n);
00673         case SOAP_TYPE_acq2xx__acq2scriptResponse:
00674                 return (void*)soap_instantiate_acq2xx__acq2scriptResponse(soap, -1, type, arrayType, n);
00675         case SOAP_TYPE_acq2xx__acq2script:
00676                 return (void*)soap_instantiate_acq2xx__acq2script(soap, -1, type, arrayType, n);
00677         case SOAP_TYPE_acq2xx__ShellTransaction:
00678                 return (void*)soap_instantiate_acq2xx__ShellTransaction(soap, -1, type, arrayType, n);
00679         case SOAP_TYPE_acq2xx__AcqStatus:
00680                 return (void*)soap_instantiate_acq2xx__AcqStatus(soap, -1, type, arrayType, n);
00681         case SOAP_TYPE_acq2xx__getAcqStatus:
00682                 return (void*)soap_instantiate_acq2xx__getAcqStatus(soap, -1, type, arrayType, n);
00683         case SOAP_TYPE_acq2xx__setArm:
00684                 return (void*)soap_instantiate_acq2xx__setArm(soap, -1, type, arrayType, n);
00685         case SOAP_TYPE_acq2xx__waitStop:
00686                 return (void*)soap_instantiate_acq2xx__waitStop(soap, -1, type, arrayType, n);
00687         case SOAP_TYPE_acq2xx__Signal:
00688                 return (void*)soap_instantiate_acq2xx__Signal(soap, -1, type, arrayType, n);
00689         case SOAP_TYPE_acq2xx__ModeSetTransaction:
00690                 return (void*)soap_instantiate_acq2xx__ModeSetTransaction(soap, -1, type, arrayType, n);
00691         case SOAP_TYPE_acq2xx__ClockSetTransaction:
00692                 return (void*)soap_instantiate_acq2xx__ClockSetTransaction(soap, -1, type, arrayType, n);
00693         case SOAP_TYPE_acq2xx__InternalClockSetTransaction:
00694                 return (void*)soap_instantiate_acq2xx__InternalClockSetTransaction(soap, -1, type, arrayType, n);
00695         case SOAP_TYPE_acq2xx__ExternalClockSetTransaction:
00696                 return (void*)soap_instantiate_acq2xx__ExternalClockSetTransaction(soap, -1, type, arrayType, n);
00697         case SOAP_TYPE_acq2xx__SignalSetTransaction:
00698                 return (void*)soap_instantiate_acq2xx__SignalSetTransaction(soap, -1, type, arrayType, n);
00699         case SOAP_TYPE_acq2xx__AcqControlTransaction:
00700                 return (void*)soap_instantiate_acq2xx__AcqControlTransaction(soap, -1, type, arrayType, n);
00701         case SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction:
00702                 return (void*)soap_instantiate_acq2xx__GetAvailableChannelsTransaction(soap, -1, type, arrayType, n);
00703         case SOAP_TYPE_VRange:
00704                 return (void*)soap_instantiate_VRange(soap, -1, type, arrayType, n);
00705         case SOAP_TYPE_VRangeData:
00706                 return (void*)soap_instantiate_VRangeData(soap, -1, type, arrayType, n);
00707         case SOAP_TYPE_acq2xx__GetVRangeTransaction:
00708                 return (void*)soap_instantiate_acq2xx__GetVRangeTransaction(soap, -1, type, arrayType, n);
00709         }
00710         return NULL;
00711 }
00712 
00713 SOAP_FMAC3 void SOAP_FMAC4 soap_fdelete(struct soap_clist *p)
00714 {       switch (p->type)
00715         {
00716         case SOAP_TYPE_acq2xx__getVersionResponse:
00717                 if (p->size < 0)
00718                         delete (struct acq2xx__getVersionResponse*)p->ptr;
00719                 else
00720                         delete[] (struct acq2xx__getVersionResponse*)p->ptr;
00721                 break;
00722         case SOAP_TYPE_acq2xx__getVersion:
00723                 if (p->size < 0)
00724                         delete (struct acq2xx__getVersion*)p->ptr;
00725                 else
00726                         delete[] (struct acq2xx__getVersion*)p->ptr;
00727                 break;
00728         case SOAP_TYPE_acq2xx__acqcmdResponse:
00729                 if (p->size < 0)
00730                         delete (struct acq2xx__acqcmdResponse*)p->ptr;
00731                 else
00732                         delete[] (struct acq2xx__acqcmdResponse*)p->ptr;
00733                 break;
00734         case SOAP_TYPE_acq2xx__acqcmd:
00735                 if (p->size < 0)
00736                         delete (struct acq2xx__acqcmd*)p->ptr;
00737                 else
00738                         delete[] (struct acq2xx__acqcmd*)p->ptr;
00739                 break;
00740         case SOAP_TYPE_acq2xx__acq2shResponse:
00741                 if (p->size < 0)
00742                         delete (struct acq2xx__acq2shResponse*)p->ptr;
00743                 else
00744                         delete[] (struct acq2xx__acq2shResponse*)p->ptr;
00745                 break;
00746         case SOAP_TYPE_acq2xx__acq2sh:
00747                 if (p->size < 0)
00748                         delete (struct acq2xx__acq2sh*)p->ptr;
00749                 else
00750                         delete[] (struct acq2xx__acq2sh*)p->ptr;
00751                 break;
00752         case SOAP_TYPE_acq2xx__Object:
00753                 if (p->size < 0)
00754                         delete (acq2xx__Object*)p->ptr;
00755                 else
00756                         delete[] (acq2xx__Object*)p->ptr;
00757                 break;
00758         case SOAP_TYPE_acq2xx__Transaction:
00759                 if (p->size < 0)
00760                         delete (acq2xx__Transaction*)p->ptr;
00761                 else
00762                         delete[] (acq2xx__Transaction*)p->ptr;
00763                 break;
00764         case SOAP_TYPE_acq2xx__TransactionList:
00765                 if (p->size < 0)
00766                         delete (acq2xx__TransactionList*)p->ptr;
00767                 else
00768                         delete[] (acq2xx__TransactionList*)p->ptr;
00769                 break;
00770         case SOAP_TYPE_acq2xx__acq2scriptResponse:
00771                 if (p->size < 0)
00772                         delete (struct acq2xx__acq2scriptResponse*)p->ptr;
00773                 else
00774                         delete[] (struct acq2xx__acq2scriptResponse*)p->ptr;
00775                 break;
00776         case SOAP_TYPE_acq2xx__acq2script:
00777                 if (p->size < 0)
00778                         delete (struct acq2xx__acq2script*)p->ptr;
00779                 else
00780                         delete[] (struct acq2xx__acq2script*)p->ptr;
00781                 break;
00782         case SOAP_TYPE_acq2xx__ShellTransaction:
00783                 if (p->size < 0)
00784                         delete (acq2xx__ShellTransaction*)p->ptr;
00785                 else
00786                         delete[] (acq2xx__ShellTransaction*)p->ptr;
00787                 break;
00788         case SOAP_TYPE_acq2xx__AcqStatus:
00789                 if (p->size < 0)
00790                         delete (struct acq2xx__AcqStatus*)p->ptr;
00791                 else
00792                         delete[] (struct acq2xx__AcqStatus*)p->ptr;
00793                 break;
00794         case SOAP_TYPE_acq2xx__getAcqStatus:
00795                 if (p->size < 0)
00796                         delete (struct acq2xx__getAcqStatus*)p->ptr;
00797                 else
00798                         delete[] (struct acq2xx__getAcqStatus*)p->ptr;
00799                 break;
00800         case SOAP_TYPE_acq2xx__setArm:
00801                 if (p->size < 0)
00802                         delete (struct acq2xx__setArm*)p->ptr;
00803                 else
00804                         delete[] (struct acq2xx__setArm*)p->ptr;
00805                 break;
00806         case SOAP_TYPE_acq2xx__waitStop:
00807                 if (p->size < 0)
00808                         delete (struct acq2xx__waitStop*)p->ptr;
00809                 else
00810                         delete[] (struct acq2xx__waitStop*)p->ptr;
00811                 break;
00812         case SOAP_TYPE_acq2xx__Signal:
00813                 if (p->size < 0)
00814                         delete (struct acq2xx__Signal*)p->ptr;
00815                 else
00816                         delete[] (struct acq2xx__Signal*)p->ptr;
00817                 break;
00818         case SOAP_TYPE_acq2xx__ModeSetTransaction:
00819                 if (p->size < 0)
00820                         delete (acq2xx__ModeSetTransaction*)p->ptr;
00821                 else
00822                         delete[] (acq2xx__ModeSetTransaction*)p->ptr;
00823                 break;
00824         case SOAP_TYPE_acq2xx__ClockSetTransaction:
00825                 if (p->size < 0)
00826                         delete (acq2xx__ClockSetTransaction*)p->ptr;
00827                 else
00828                         delete[] (acq2xx__ClockSetTransaction*)p->ptr;
00829                 break;
00830         case SOAP_TYPE_acq2xx__InternalClockSetTransaction:
00831                 if (p->size < 0)
00832                         delete (acq2xx__InternalClockSetTransaction*)p->ptr;
00833                 else
00834                         delete[] (acq2xx__InternalClockSetTransaction*)p->ptr;
00835                 break;
00836         case SOAP_TYPE_acq2xx__ExternalClockSetTransaction:
00837                 if (p->size < 0)
00838                         delete (acq2xx__ExternalClockSetTransaction*)p->ptr;
00839                 else
00840                         delete[] (acq2xx__ExternalClockSetTransaction*)p->ptr;
00841                 break;
00842         case SOAP_TYPE_acq2xx__SignalSetTransaction:
00843                 if (p->size < 0)
00844                         delete (acq2xx__SignalSetTransaction*)p->ptr;
00845                 else
00846                         delete[] (acq2xx__SignalSetTransaction*)p->ptr;
00847                 break;
00848         case SOAP_TYPE_acq2xx__AcqControlTransaction:
00849                 if (p->size < 0)
00850                         delete (acq2xx__AcqControlTransaction*)p->ptr;
00851                 else
00852                         delete[] (acq2xx__AcqControlTransaction*)p->ptr;
00853                 break;
00854         case SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction:
00855                 if (p->size < 0)
00856                         delete (acq2xx__GetAvailableChannelsTransaction*)p->ptr;
00857                 else
00858                         delete[] (acq2xx__GetAvailableChannelsTransaction*)p->ptr;
00859                 break;
00860         case SOAP_TYPE_VRange:
00861                 if (p->size < 0)
00862                         delete (struct VRange*)p->ptr;
00863                 else
00864                         delete[] (struct VRange*)p->ptr;
00865                 break;
00866         case SOAP_TYPE_VRangeData:
00867                 if (p->size < 0)
00868                         delete (struct VRangeData*)p->ptr;
00869                 else
00870                         delete[] (struct VRangeData*)p->ptr;
00871                 break;
00872         case SOAP_TYPE_acq2xx__GetVRangeTransaction:
00873                 if (p->size < 0)
00874                         delete (acq2xx__GetVRangeTransaction*)p->ptr;
00875                 else
00876                         delete[] (acq2xx__GetVRangeTransaction*)p->ptr;
00877                 break;
00878         case SOAP_TYPE_SOAP_ENV__Header:
00879                 if (p->size < 0)
00880                         delete (struct SOAP_ENV__Header*)p->ptr;
00881                 else
00882                         delete[] (struct SOAP_ENV__Header*)p->ptr;
00883                 break;
00884         case SOAP_TYPE_SOAP_ENV__Code:
00885                 if (p->size < 0)
00886                         delete (struct SOAP_ENV__Code*)p->ptr;
00887                 else
00888                         delete[] (struct SOAP_ENV__Code*)p->ptr;
00889                 break;
00890         case SOAP_TYPE_SOAP_ENV__Detail:
00891                 if (p->size < 0)
00892                         delete (struct SOAP_ENV__Detail*)p->ptr;
00893                 else
00894                         delete[] (struct SOAP_ENV__Detail*)p->ptr;
00895                 break;
00896         case SOAP_TYPE_SOAP_ENV__Reason:
00897                 if (p->size < 0)
00898                         delete (struct SOAP_ENV__Reason*)p->ptr;
00899                 else
00900                         delete[] (struct SOAP_ENV__Reason*)p->ptr;
00901                 break;
00902         case SOAP_TYPE_SOAP_ENV__Fault:
00903                 if (p->size < 0)
00904                         delete (struct SOAP_ENV__Fault*)p->ptr;
00905                 else
00906                         delete[] (struct SOAP_ENV__Fault*)p->ptr;
00907                 break;
00908         }
00909 }
00910 
00911 SOAP_FMAC3 void* SOAP_FMAC4 soap_class_id_enter(struct soap *soap, const char *id, void *p, int t, size_t n, const char *type, const char *arrayType)
00912 {       return soap_id_enter(soap, id, p, t, n, 0, type, arrayType, soap_instantiate);
00913 }
00914 
00915 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
00916 {       (void)soap; /* appease -Wall -Werror */
00917 #ifdef SOAP_DEFAULT_byte
00918         *a = SOAP_DEFAULT_byte;
00919 #else
00920         *a = (char)0;
00921 #endif
00922 }
00923 
00924 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
00925 {
00926         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_byte);
00927         if (soap_out_byte(soap, tag, id, a, type))
00928                 return soap->error;
00929         return soap_putindependent(soap);
00930 }
00931 
00932 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
00933 {
00934         return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_byte);
00935 }
00936 
00937 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
00938 {
00939         if ((p = soap_in_byte(soap, tag, p, type)))
00940                 soap_getindependent(soap);
00941         return p;
00942 }
00943 
00944 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
00945 {
00946         return soap_inbyte(soap, tag, a, type, SOAP_TYPE_byte);
00947 }
00948 
00949 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
00950 {       (void)soap; /* appease -Wall -Werror */
00951 #ifdef SOAP_DEFAULT_int
00952         *a = SOAP_DEFAULT_int;
00953 #else
00954         *a = (int)0;
00955 #endif
00956 }
00957 
00958 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
00959 {
00960         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_int);
00961         if (soap_out_int(soap, tag, id, a, type))
00962                 return soap->error;
00963         return soap_putindependent(soap);
00964 }
00965 
00966 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
00967 {
00968         return soap_outint(soap, tag, id, a, type, SOAP_TYPE_int);
00969 }
00970 
00971 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
00972 {
00973         if ((p = soap_in_int(soap, tag, p, type)))
00974                 soap_getindependent(soap);
00975         return p;
00976 }
00977 
00978 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
00979 {
00980         return soap_inint(soap, tag, a, type, SOAP_TYPE_int);
00981 }
00982 
00983 SOAP_FMAC3 void SOAP_FMAC4 soap_default_float(struct soap *soap, float *a)
00984 {       (void)soap; /* appease -Wall -Werror */
00985 #ifdef SOAP_DEFAULT_float
00986         *a = SOAP_DEFAULT_float;
00987 #else
00988         *a = (float)0;
00989 #endif
00990 }
00991 
00992 SOAP_FMAC3 int SOAP_FMAC4 soap_put_float(struct soap *soap, const float *a, const char *tag, const char *type)
00993 {
00994         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_float);
00995         if (soap_out_float(soap, tag, id, a, type))
00996                 return soap->error;
00997         return soap_putindependent(soap);
00998 }
00999 
01000 SOAP_FMAC3 int SOAP_FMAC4 soap_out_float(struct soap *soap, const char *tag, int id, const float *a, const char *type)
01001 {
01002         return soap_outfloat(soap, tag, id, a, type, SOAP_TYPE_float);
01003 }
01004 
01005 SOAP_FMAC3 float * SOAP_FMAC4 soap_get_float(struct soap *soap, float *p, const char *tag, const char *type)
01006 {
01007         if ((p = soap_in_float(soap, tag, p, type)))
01008                 soap_getindependent(soap);
01009         return p;
01010 }
01011 
01012 SOAP_FMAC3 float * SOAP_FMAC4 soap_in_float(struct soap *soap, const char *tag, float *a, const char *type)
01013 {
01014         return soap_infloat(soap, tag, a, type, SOAP_TYPE_float);
01015 }
01016 
01017 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__MODE(struct soap *soap, enum acq2xx__MODE *a)
01018 {       (void)soap; /* appease -Wall -Werror */
01019 #ifdef SOAP_DEFAULT_acq2xx__MODE
01020         *a = SOAP_DEFAULT_acq2xx__MODE;
01021 #else
01022         *a = (enum acq2xx__MODE)0;
01023 #endif
01024 }
01025 
01026 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__MODE(struct soap *soap, const enum acq2xx__MODE *a, const char *tag, const char *type)
01027 {
01028         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__MODE);
01029         if (soap_out_acq2xx__MODE(soap, tag, id, a, type))
01030                 return soap->error;
01031         return soap_putindependent(soap);
01032 }
01033 
01034 static const struct soap_code_map soap_codes_acq2xx__MODE[] =
01035 {       { (long)MODE_SOFT_TRANSIENT, "MODE-SOFT-TRANSIENT" },
01036         { (long)MODE_TRIGGERED_CONTINUOUS, "MODE-TRIGGERED-CONTINUOUS" },
01037         { (long)MODE_GATED_TRANSIENT, "MODE-GATED-TRANSIENT" },
01038         { (long)MODE_SOFT_CONTINUOUS, "MODE-SOFT-CONTINUOUS" },
01039         { 0, NULL }
01040 };
01041 
01042 SOAP_FMAC3S const char* SOAP_FMAC4S soap_acq2xx__MODE2s(struct soap *soap, enum acq2xx__MODE n)
01043 {       const char *s = soap_code_str(soap_codes_acq2xx__MODE, (long)n);
01044         if (s)
01045                 return s;
01046         return soap_long2s(soap, (long)n);
01047 }
01048 
01049 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__MODE(struct soap *soap, const char *tag, int id, const enum acq2xx__MODE *a, const char *type)
01050 {       soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__MODE), type);
01051         soap_send(soap, soap_acq2xx__MODE2s(soap, *a));
01052         return soap_element_end_out(soap, tag);
01053 }
01054 
01055 SOAP_FMAC3 enum acq2xx__MODE * SOAP_FMAC4 soap_get_acq2xx__MODE(struct soap *soap, enum acq2xx__MODE *p, const char *tag, const char *type)
01056 {
01057         if ((p = soap_in_acq2xx__MODE(soap, tag, p, type)))
01058                 soap_getindependent(soap);
01059         return p;
01060 }
01061 
01062 SOAP_FMAC3S int SOAP_FMAC4S soap_s2acq2xx__MODE(struct soap *soap, const char *s, enum acq2xx__MODE *a)
01063 {
01064         const struct soap_code_map *map;
01065         if (!s)
01066                 return SOAP_OK;
01067         map = soap_code(soap_codes_acq2xx__MODE, s);
01068         if (map)
01069                 *a = (enum acq2xx__MODE)map->code;
01070         else
01071         {       long n;
01072                 if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 3)))
01073                         return soap->error = SOAP_TYPE;
01074                 *a = (enum acq2xx__MODE)n;
01075         }
01076         return SOAP_OK;
01077 }
01078 
01079 SOAP_FMAC3 enum acq2xx__MODE * SOAP_FMAC4 soap_in_acq2xx__MODE(struct soap *soap, const char *tag, enum acq2xx__MODE *a, const char *type)
01080 {
01081         if (soap_element_begin_in(soap, tag, 0, type))
01082                 return NULL;
01083         a = (enum acq2xx__MODE *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__MODE, sizeof(enum acq2xx__MODE), 0, NULL, NULL, NULL);
01084         if (!a)
01085                 return NULL;
01086         if (soap->body && !*soap->href)
01087         {       if (!a || soap_s2acq2xx__MODE(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
01088                         return NULL;
01089         }
01090         else
01091         {       a = (enum acq2xx__MODE *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__MODE, 0, sizeof(enum acq2xx__MODE), 0, NULL);
01092                 if (soap->body && soap_element_end_in(soap, tag))
01093                         return NULL;
01094         }
01095         return a;
01096 }
01097 
01098 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__DOx(struct soap *soap, enum acq2xx__DOx *a)
01099 {       (void)soap; /* appease -Wall -Werror */
01100 #ifdef SOAP_DEFAULT_acq2xx__DOx
01101         *a = SOAP_DEFAULT_acq2xx__DOx;
01102 #else
01103         *a = (enum acq2xx__DOx)0;
01104 #endif
01105 }
01106 
01107 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__DOx(struct soap *soap, const enum acq2xx__DOx *a, const char *tag, const char *type)
01108 {
01109         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__DOx);
01110         if (soap_out_acq2xx__DOx(soap, tag, id, a, type))
01111                 return soap->error;
01112         return soap_putindependent(soap);
01113 }
01114 
01115 static const struct soap_code_map soap_codes_acq2xx__DOx[] =
01116 {       { (long)DO_NONE, "DO-NONE" },
01117         { (long)DO0, "DO0" },
01118         { (long)DO1, "DO1" },
01119         { (long)DO2, "DO2" },
01120         { (long)DO3, "DO3" },
01121         { (long)DO4, "DO4" },
01122         { (long)DO5, "DO5" },
01123         { 0, NULL }
01124 };
01125 
01126 SOAP_FMAC3S const char* SOAP_FMAC4S soap_acq2xx__DOx2s(struct soap *soap, enum acq2xx__DOx n)
01127 {       const char *s = soap_code_str(soap_codes_acq2xx__DOx, (long)n);
01128         if (s)
01129                 return s;
01130         return soap_long2s(soap, (long)n);
01131 }
01132 
01133 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__DOx(struct soap *soap, const char *tag, int id, const enum acq2xx__DOx *a, const char *type)
01134 {       soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__DOx), type);
01135         soap_send(soap, soap_acq2xx__DOx2s(soap, *a));
01136         return soap_element_end_out(soap, tag);
01137 }
01138 
01139 SOAP_FMAC3 enum acq2xx__DOx * SOAP_FMAC4 soap_get_acq2xx__DOx(struct soap *soap, enum acq2xx__DOx *p, const char *tag, const char *type)
01140 {
01141         if ((p = soap_in_acq2xx__DOx(soap, tag, p, type)))
01142                 soap_getindependent(soap);
01143         return p;
01144 }
01145 
01146 SOAP_FMAC3S int SOAP_FMAC4S soap_s2acq2xx__DOx(struct soap *soap, const char *s, enum acq2xx__DOx *a)
01147 {
01148         const struct soap_code_map *map;
01149         if (!s)
01150                 return SOAP_OK;
01151         map = soap_code(soap_codes_acq2xx__DOx, s);
01152         if (map)
01153                 *a = (enum acq2xx__DOx)map->code;
01154         else
01155         {       long n;
01156                 if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 6)))
01157                         return soap->error = SOAP_TYPE;
01158                 *a = (enum acq2xx__DOx)n;
01159         }
01160         return SOAP_OK;
01161 }
01162 
01163 SOAP_FMAC3 enum acq2xx__DOx * SOAP_FMAC4 soap_in_acq2xx__DOx(struct soap *soap, const char *tag, enum acq2xx__DOx *a, const char *type)
01164 {
01165         if (soap_element_begin_in(soap, tag, 0, type))
01166                 return NULL;
01167         a = (enum acq2xx__DOx *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__DOx, sizeof(enum acq2xx__DOx), 0, NULL, NULL, NULL);
01168         if (!a)
01169                 return NULL;
01170         if (soap->body && !*soap->href)
01171         {       if (!a || soap_s2acq2xx__DOx(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
01172                         return NULL;
01173         }
01174         else
01175         {       a = (enum acq2xx__DOx *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__DOx, 0, sizeof(enum acq2xx__DOx), 0, NULL);
01176                 if (soap->body && soap_element_end_in(soap, tag))
01177                         return NULL;
01178         }
01179         return a;
01180 }
01181 
01182 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__DIx(struct soap *soap, enum acq2xx__DIx *a)
01183 {       (void)soap; /* appease -Wall -Werror */
01184 #ifdef SOAP_DEFAULT_acq2xx__DIx
01185         *a = SOAP_DEFAULT_acq2xx__DIx;
01186 #else
01187         *a = (enum acq2xx__DIx)0;
01188 #endif
01189 }
01190 
01191 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__DIx(struct soap *soap, const enum acq2xx__DIx *a, const char *tag, const char *type)
01192 {
01193         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__DIx);
01194         if (soap_out_acq2xx__DIx(soap, tag, id, a, type))
01195                 return soap->error;
01196         return soap_putindependent(soap);
01197 }
01198 
01199 static const struct soap_code_map soap_codes_acq2xx__DIx[] =
01200 {       { (long)DI_NONE, "DI-NONE" },
01201         { (long)DI0, "DI0" },
01202         { (long)DI1, "DI1" },
01203         { (long)DI2, "DI2" },
01204         { (long)DI3, "DI3" },
01205         { (long)DI4, "DI4" },
01206         { (long)DI5, "DI5" },
01207         { 0, NULL }
01208 };
01209 
01210 SOAP_FMAC3S const char* SOAP_FMAC4S soap_acq2xx__DIx2s(struct soap *soap, enum acq2xx__DIx n)
01211 {       const char *s = soap_code_str(soap_codes_acq2xx__DIx, (long)n);
01212         if (s)
01213                 return s;
01214         return soap_long2s(soap, (long)n);
01215 }
01216 
01217 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__DIx(struct soap *soap, const char *tag, int id, const enum acq2xx__DIx *a, const char *type)
01218 {       soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__DIx), type);
01219         soap_send(soap, soap_acq2xx__DIx2s(soap, *a));
01220         return soap_element_end_out(soap, tag);
01221 }
01222 
01223 SOAP_FMAC3 enum acq2xx__DIx * SOAP_FMAC4 soap_get_acq2xx__DIx(struct soap *soap, enum acq2xx__DIx *p, const char *tag, const char *type)
01224 {
01225         if ((p = soap_in_acq2xx__DIx(soap, tag, p, type)))
01226                 soap_getindependent(soap);
01227         return p;
01228 }
01229 
01230 SOAP_FMAC3S int SOAP_FMAC4S soap_s2acq2xx__DIx(struct soap *soap, const char *s, enum acq2xx__DIx *a)
01231 {
01232         const struct soap_code_map *map;
01233         if (!s)
01234                 return SOAP_OK;
01235         map = soap_code(soap_codes_acq2xx__DIx, s);
01236         if (map)
01237                 *a = (enum acq2xx__DIx)map->code;
01238         else
01239         {       long n;
01240                 if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 6)))
01241                         return soap->error = SOAP_TYPE;
01242                 *a = (enum acq2xx__DIx)n;
01243         }
01244         return SOAP_OK;
01245 }
01246 
01247 SOAP_FMAC3 enum acq2xx__DIx * SOAP_FMAC4 soap_in_acq2xx__DIx(struct soap *soap, const char *tag, enum acq2xx__DIx *a, const char *type)
01248 {
01249         if (soap_element_begin_in(soap, tag, 0, type))
01250                 return NULL;
01251         a = (enum acq2xx__DIx *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__DIx, sizeof(enum acq2xx__DIx), 0, NULL, NULL, NULL);
01252         if (!a)
01253                 return NULL;
01254         if (soap->body && !*soap->href)
01255         {       if (!a || soap_s2acq2xx__DIx(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
01256                         return NULL;
01257         }
01258         else
01259         {       a = (enum acq2xx__DIx *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__DIx, 0, sizeof(enum acq2xx__DIx), 0, NULL);
01260                 if (soap->body && soap_element_end_in(soap, tag))
01261                         return NULL;
01262         }
01263         return a;
01264 }
01265 
01266 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__EDGE(struct soap *soap, enum acq2xx__EDGE *a)
01267 {       (void)soap; /* appease -Wall -Werror */
01268 #ifdef SOAP_DEFAULT_acq2xx__EDGE
01269         *a = SOAP_DEFAULT_acq2xx__EDGE;
01270 #else
01271         *a = (enum acq2xx__EDGE)0;
01272 #endif
01273 }
01274 
01275 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__EDGE(struct soap *soap, const enum acq2xx__EDGE *a, const char *tag, const char *type)
01276 {
01277         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__EDGE);
01278         if (soap_out_acq2xx__EDGE(soap, tag, id, a, type))
01279                 return soap->error;
01280         return soap_putindependent(soap);
01281 }
01282 
01283 static const struct soap_code_map soap_codes_acq2xx__EDGE[] =
01284 {       { (long)EDGE_FALLING, "EDGE-FALLING" },
01285         { (long)EDGE_RISING, "EDGE-RISING" },
01286         { 0, NULL }
01287 };
01288 
01289 SOAP_FMAC3S const char* SOAP_FMAC4S soap_acq2xx__EDGE2s(struct soap *soap, enum acq2xx__EDGE n)
01290 {       const char *s = soap_code_str(soap_codes_acq2xx__EDGE, (long)n);
01291         if (s)
01292                 return s;
01293         return soap_long2s(soap, (long)n);
01294 }
01295 
01296 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__EDGE(struct soap *soap, const char *tag, int id, const enum acq2xx__EDGE *a, const char *type)
01297 {       soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__EDGE), type);
01298         soap_send(soap, soap_acq2xx__EDGE2s(soap, *a));
01299         return soap_element_end_out(soap, tag);
01300 }
01301 
01302 SOAP_FMAC3 enum acq2xx__EDGE * SOAP_FMAC4 soap_get_acq2xx__EDGE(struct soap *soap, enum acq2xx__EDGE *p, const char *tag, const char *type)
01303 {
01304         if ((p = soap_in_acq2xx__EDGE(soap, tag, p, type)))
01305                 soap_getindependent(soap);
01306         return p;
01307 }
01308 
01309 SOAP_FMAC3S int SOAP_FMAC4S soap_s2acq2xx__EDGE(struct soap *soap, const char *s, enum acq2xx__EDGE *a)
01310 {
01311         const struct soap_code_map *map;
01312         if (!s)
01313                 return SOAP_OK;
01314         map = soap_code(soap_codes_acq2xx__EDGE, s);
01315         if (map)
01316                 *a = (enum acq2xx__EDGE)map->code;
01317         else
01318         {       long n;
01319                 if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 1)))
01320                         return soap->error = SOAP_TYPE;
01321                 *a = (enum acq2xx__EDGE)n;
01322         }
01323         return SOAP_OK;
01324 }
01325 
01326 SOAP_FMAC3 enum acq2xx__EDGE * SOAP_FMAC4 soap_in_acq2xx__EDGE(struct soap *soap, const char *tag, enum acq2xx__EDGE *a, const char *type)
01327 {
01328         if (soap_element_begin_in(soap, tag, 0, type))
01329                 return NULL;
01330         a = (enum acq2xx__EDGE *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__EDGE, sizeof(enum acq2xx__EDGE), 0, NULL, NULL, NULL);
01331         if (!a)
01332                 return NULL;
01333         if (soap->body && !*soap->href)
01334         {       if (!a || soap_s2acq2xx__EDGE(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
01335                         return NULL;
01336         }
01337         else
01338         {       a = (enum acq2xx__EDGE *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__EDGE, 0, sizeof(enum acq2xx__EDGE), 0, NULL);
01339                 if (soap->body && soap_element_end_in(soap, tag))
01340                         return NULL;
01341         }
01342         return a;
01343 }
01344 
01345 SOAP_FMAC3 void SOAP_FMAC4 soap_default_bool(struct soap *soap, bool *a)
01346 {       (void)soap; /* appease -Wall -Werror */
01347 #ifdef SOAP_DEFAULT_bool
01348         *a = SOAP_DEFAULT_bool;
01349 #else
01350         *a = (bool)0;
01351 #endif
01352 }
01353 
01354 SOAP_FMAC3 int SOAP_FMAC4 soap_put_bool(struct soap *soap, const bool *a, const char *tag, const char *type)
01355 {
01356         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_bool);
01357         if (soap_out_bool(soap, tag, id, a, type))
01358                 return soap->error;
01359         return soap_putindependent(soap);
01360 }
01361 
01362 static const struct soap_code_map soap_codes_bool[] =
01363 {       { (long)false, "false" },
01364         { (long)true, "true" },
01365         { 0, NULL }
01366 };
01367 
01368 SOAP_FMAC3S const char* SOAP_FMAC4S soap_bool2s(struct soap *soap, bool n)
01369 {       const char *s = soap_code_str(soap_codes_bool, (long)n);
01370         if (s)
01371                 return s;
01372         return soap_long2s(soap, (long)n);
01373 }
01374 
01375 SOAP_FMAC3 int SOAP_FMAC4 soap_out_bool(struct soap *soap, const char *tag, int id, const bool *a, const char *type)
01376 {       soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_bool), type);
01377         soap_send(soap, soap_bool2s(soap, *a));
01378         return soap_element_end_out(soap, tag);
01379 }
01380 
01381 SOAP_FMAC3 bool * SOAP_FMAC4 soap_get_bool(struct soap *soap, bool *p, const char *tag, const char *type)
01382 {
01383         if ((p = soap_in_bool(soap, tag, p, type)))
01384                 soap_getindependent(soap);
01385         return p;
01386 }
01387 
01388 SOAP_FMAC3S int SOAP_FMAC4S soap_s2bool(struct soap *soap, const char *s, bool *a)
01389 {
01390         const struct soap_code_map *map;
01391         if (!s)
01392                 return SOAP_OK;
01393         map = soap_code(soap_codes_bool, s);
01394         if (map)
01395                 *a = (bool)(map->code != 0);
01396         else
01397         {       long n;
01398                 if (soap_s2long(soap, s, &n) || n < 0 || n > 1)
01399                         return soap->error = SOAP_TYPE;
01400                 *a = (bool)(n != 0);
01401         }
01402         return SOAP_OK;
01403 }
01404 
01405 SOAP_FMAC3 bool * SOAP_FMAC4 soap_in_bool(struct soap *soap, const char *tag, bool *a, const char *type)
01406 {
01407         if (soap_element_begin_in(soap, tag, 0, NULL))
01408                 return NULL;
01409         if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":boolean"))
01410         {       soap->error = SOAP_TYPE;
01411                 return NULL;
01412         }
01413         a = (bool *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_bool, sizeof(bool), 0, NULL, NULL, NULL);
01414         if (!a)
01415                 return NULL;
01416         if (soap->body && !*soap->href)
01417         {       if (!a || soap_s2bool(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
01418                         return NULL;
01419         }
01420         else
01421         {       a = (bool *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_bool, 0, sizeof(bool), 0, NULL);
01422                 if (soap->body && soap_element_end_in(soap, tag))
01423                         return NULL;
01424         }
01425         return a;
01426 }
01427 
01428 SOAP_FMAC3 void SOAP_FMAC4 soap_default_STATE(struct soap *soap, enum STATE *a)
01429 {       (void)soap; /* appease -Wall -Werror */
01430 #ifdef SOAP_DEFAULT_STATE
01431         *a = SOAP_DEFAULT_STATE;
01432 #else
01433         *a = (enum STATE)0;
01434 #endif
01435 }
01436 
01437 SOAP_FMAC3 int SOAP_FMAC4 soap_put_STATE(struct soap *soap, const enum STATE *a, const char *tag, const char *type)
01438 {
01439         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_STATE);
01440         if (soap_out_STATE(soap, tag, id, a, type))
01441                 return soap->error;
01442         return soap_putindependent(soap);
01443 }
01444 
01445 static const struct soap_code_map soap_codes_STATE[] =
01446 {       { (long)ST_STOP, "ST-STOP" },
01447         { (long)ST_ARM, "ST-ARM" },
01448         { (long)ST_RUN, "ST-RUN" },
01449         { (long)ST_TRIGGER, "ST-TRIGGER" },
01450         { (long)ST_POSTPROCESS, "ST-POSTPROCESS" },
01451         { (long)ST_CAPDONE, "ST-CAPDONE" },
01452         { 0, NULL }
01453 };
01454 
01455 SOAP_FMAC3S const char* SOAP_FMAC4S soap_STATE2s(struct soap *soap, enum STATE n)
01456 {       const char *s = soap_code_str(soap_codes_STATE, (long)n);
01457         if (s)
01458                 return s;
01459         return soap_long2s(soap, (long)n);
01460 }
01461 
01462 SOAP_FMAC3 int SOAP_FMAC4 soap_out_STATE(struct soap *soap, const char *tag, int id, const enum STATE *a, const char *type)
01463 {       soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_STATE), type);
01464         soap_send(soap, soap_STATE2s(soap, *a));
01465         return soap_element_end_out(soap, tag);
01466 }
01467 
01468 SOAP_FMAC3 enum STATE * SOAP_FMAC4 soap_get_STATE(struct soap *soap, enum STATE *p, const char *tag, const char *type)
01469 {
01470         if ((p = soap_in_STATE(soap, tag, p, type)))
01471                 soap_getindependent(soap);
01472         return p;
01473 }
01474 
01475 SOAP_FMAC3S int SOAP_FMAC4S soap_s2STATE(struct soap *soap, const char *s, enum STATE *a)
01476 {
01477         const struct soap_code_map *map;
01478         if (!s)
01479                 return SOAP_OK;
01480         map = soap_code(soap_codes_STATE, s);
01481         if (map)
01482                 *a = (enum STATE)map->code;
01483         else
01484         {       long n;
01485                 if (soap_s2long(soap, s, &n) || ((soap->mode & SOAP_XML_STRICT) && (n < 0 || n > 5)))
01486                         return soap->error = SOAP_TYPE;
01487                 *a = (enum STATE)n;
01488         }
01489         return SOAP_OK;
01490 }
01491 
01492 SOAP_FMAC3 enum STATE * SOAP_FMAC4 soap_in_STATE(struct soap *soap, const char *tag, enum STATE *a, const char *type)
01493 {
01494         if (soap_element_begin_in(soap, tag, 0, type))
01495                 return NULL;
01496         a = (enum STATE *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_STATE, sizeof(enum STATE), 0, NULL, NULL, NULL);
01497         if (!a)
01498                 return NULL;
01499         if (soap->body && !*soap->href)
01500         {       if (!a || soap_s2STATE(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
01501                         return NULL;
01502         }
01503         else
01504         {       a = (enum STATE *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_STATE, 0, sizeof(enum STATE), 0, NULL);
01505                 if (soap->body && soap_element_end_in(soap, tag))
01506                         return NULL;
01507         }
01508         return a;
01509 }
01510 
01511 void acq2xx__GetVRangeTransaction::soap_serialize(struct soap *soap) const
01512 {
01513         (void)soap; /* appease -Wall -Werror */
01514         soap_serialize_PointerToacq2xx__GetAvailableChannelsTransaction(soap, &((acq2xx__GetVRangeTransaction*)this)->channels);
01515         soap_serialize_VRangeData(soap, &((acq2xx__GetVRangeTransaction*)this)->ranges);
01516         /* transient acq2xx__GetVRangeTransaction skipped */
01517         /* non-serializable getVRange skipped */
01518         /* transient run skipped */
01519         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->command);
01520         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->result);
01521         /* transient acq2xx__ShellTransaction skipped */
01522         /* transient acq2xx__ShellTransaction skipped */
01523         /* transient ~acq2xx__ShellTransaction skipped */
01524         /* transient getCommand skipped */
01525         /* transient getResult skipped */
01526         /* transient print skipped */
01527         /* transient initCommand skipped */
01528         /* transient run skipped */
01529         /* transient acq2xx__Transaction skipped */
01530         /* transient acq2xx__Transaction skipped */
01531         /* transient ~acq2xx__Transaction skipped */
01532         /* transient print skipped */
01533         /* transient exec skipped */
01534         /* transient getCommand skipped */
01535         /* transient getResult skipped */
01536         /* transient run skipped */
01537         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
01538         /* transient acq2xx__Object skipped */
01539         /* transient acq2xx__Object skipped */
01540         /* transient ~acq2xx__Object skipped */
01541         /* transient print skipped */
01542         /* transient getName skipped */
01543 }
01544 
01545 void acq2xx__GetVRangeTransaction::soap_default(struct soap *soap)
01546 {
01547         (void)soap; /* appease -Wall -Werror */
01548         ((acq2xx__GetVRangeTransaction*)this)->channels = NULL;
01549         soap_default_VRangeData(soap, &((acq2xx__GetVRangeTransaction*)this)->ranges);
01550         /* transient acq2xx__GetVRangeTransaction skipped */
01551         /* non-serializable getVRange skipped */
01552         /* transient run skipped */
01553         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->command);
01554         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->result);
01555         /* transient acq2xx__ShellTransaction skipped */
01556         /* transient acq2xx__ShellTransaction skipped */
01557         /* transient ~acq2xx__ShellTransaction skipped */
01558         /* transient getCommand skipped */
01559         /* transient getResult skipped */
01560         /* transient print skipped */
01561         /* transient initCommand skipped */
01562         /* transient run skipped */
01563         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
01564         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
01565         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
01566         /* transient acq2xx__Transaction skipped */
01567         /* transient acq2xx__Transaction skipped */
01568         /* transient ~acq2xx__Transaction skipped */
01569         /* transient print skipped */
01570         /* transient exec skipped */
01571         /* transient getCommand skipped */
01572         /* transient getResult skipped */
01573         /* transient run skipped */
01574         soap_default_string(soap, &((acq2xx__Object*)this)->name);
01575         /* transient acq2xx__Object skipped */
01576         /* transient acq2xx__Object skipped */
01577         /* transient ~acq2xx__Object skipped */
01578         /* transient print skipped */
01579         /* transient getName skipped */
01580 }
01581 
01582 int acq2xx__GetVRangeTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
01583 {
01584         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__GetVRangeTransaction);
01585         if (this->soap_out(soap, tag, id, type))
01586                 return soap->error;
01587         return soap_putindependent(soap);
01588 }
01589 
01590 int acq2xx__GetVRangeTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
01591 {
01592         return soap_out_acq2xx__GetVRangeTransaction(soap, tag, id, this, type);
01593 }
01594 
01595 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__GetVRangeTransaction(struct soap *soap, const char *tag, int id, const acq2xx__GetVRangeTransaction *a, const char *type)
01596 {
01597         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__GetVRangeTransaction), "acq2xx:GetVRangeTransaction");
01598         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
01599         /* transient acq2xx__Object skipped */
01600         /* transient acq2xx__Object skipped */
01601         /* transient ~acq2xx__Object skipped */
01602         /* transient print skipped */
01603         /* transient getName skipped */
01604         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
01605         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
01606         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
01607         /* transient acq2xx__Transaction skipped */
01608         /* transient acq2xx__Transaction skipped */
01609         /* transient ~acq2xx__Transaction skipped */
01610         /* transient print skipped */
01611         /* transient exec skipped */
01612         /* transient getCommand skipped */
01613         /* transient getResult skipped */
01614         /* transient run skipped */
01615         soap_out_string(soap, "acq2xx:command", -1, &(((acq2xx__ShellTransaction*)a)->command), "xsd:string");
01616         soap_out_string(soap, "acq2xx:result", -1, &(((acq2xx__ShellTransaction*)a)->result), "xsd:string");
01617         /* transient acq2xx__ShellTransaction skipped */
01618         /* transient acq2xx__ShellTransaction skipped */
01619         /* transient ~acq2xx__ShellTransaction skipped */
01620         /* transient getCommand skipped */
01621         /* transient getResult skipped */
01622         /* transient print skipped */
01623         /* transient initCommand skipped */
01624         /* transient run skipped */
01625         soap_out_PointerToacq2xx__GetAvailableChannelsTransaction(soap, "acq2xx:channels", -1, &(((acq2xx__GetVRangeTransaction*)a)->channels), "acq2xx:GetAvailableChannelsTransaction");
01626         soap_out_VRangeData(soap, "acq2xx:ranges", -1, &(((acq2xx__GetVRangeTransaction*)a)->ranges), "VRange");
01627         /* transient acq2xx__GetVRangeTransaction skipped */
01628         /* non-serializable getVRange skipped */
01629         /* transient run skipped */
01630         soap_element_end_out(soap, tag);
01631         return SOAP_OK;
01632 }
01633 
01634 void *acq2xx__GetVRangeTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
01635 {
01636         return soap_get_acq2xx__GetVRangeTransaction(soap, this, tag, type);
01637 }
01638 
01639 SOAP_FMAC3 acq2xx__GetVRangeTransaction * SOAP_FMAC4 soap_get_acq2xx__GetVRangeTransaction(struct soap *soap, acq2xx__GetVRangeTransaction *p, const char *tag, const char *type)
01640 {
01641         if ((p = soap_in_acq2xx__GetVRangeTransaction(soap, tag, p, type)))
01642                 soap_getindependent(soap);
01643         return p;
01644 }
01645 
01646 void *acq2xx__GetVRangeTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
01647 {       return soap_in_acq2xx__GetVRangeTransaction(soap, tag, this, type);
01648 }
01649 
01650 SOAP_FMAC3 acq2xx__GetVRangeTransaction * SOAP_FMAC4 soap_in_acq2xx__GetVRangeTransaction(struct soap *soap, const char *tag, acq2xx__GetVRangeTransaction *a, const char *type)
01651 {
01652         if (soap_element_begin_in(soap, tag, 0, NULL))
01653                 return NULL;
01654         a = (acq2xx__GetVRangeTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__GetVRangeTransaction, sizeof(acq2xx__GetVRangeTransaction), soap->type, soap->arrayType);
01655         if (!a)
01656                 return NULL;
01657         if (soap->alloced)
01658         {       a->soap_default(soap);
01659                 if (soap->clist->type != SOAP_TYPE_acq2xx__GetVRangeTransaction)
01660                 {       soap_revert(soap);
01661                         *soap->id = '\0';
01662                         return (acq2xx__GetVRangeTransaction *)a->soap_in(soap, tag, type);
01663                 }
01664         }
01665         short soap_flag_name4 = 1, soap_flag_abort_on_error3 = 1, soap_flag_status3 = 1, soap_flag_complete3 = 1, soap_flag_command2 = 1, soap_flag_result2 = 1, soap_flag_channels1 = 1, soap_flag_ranges1 = 1;
01666         if (soap->body && !*soap->href)
01667         {
01668                 for (;;)
01669                 {       soap->error = SOAP_TAG_MISMATCH;
01670                         if (soap_flag_name4 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01671                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
01672                                 {       soap_flag_name4--;
01673                                         continue;
01674                                 }
01675                         /* transient acq2xx__Object skipped */
01676                         /* transient acq2xx__Object skipped */
01677                         /* transient ~acq2xx__Object skipped */
01678                         /* transient print skipped */
01679                         /* transient getName skipped */
01680                         if (soap_flag_abort_on_error3 && soap->error == SOAP_TAG_MISMATCH)
01681                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
01682                                 {       soap_flag_abort_on_error3--;
01683                                         continue;
01684                                 }
01685                         if (soap_flag_status3 && soap->error == SOAP_TAG_MISMATCH)
01686                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
01687                                 {       soap_flag_status3--;
01688                                         continue;
01689                                 }
01690                         if (soap_flag_complete3 && soap->error == SOAP_TAG_MISMATCH)
01691                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
01692                                 {       soap_flag_complete3--;
01693                                         continue;
01694                                 }
01695                         /* transient acq2xx__Transaction skipped */
01696                         /* transient acq2xx__Transaction skipped */
01697                         /* transient ~acq2xx__Transaction skipped */
01698                         /* transient print skipped */
01699                         /* transient exec skipped */
01700                         /* transient getCommand skipped */
01701                         /* transient getResult skipped */
01702                         /* transient run skipped */
01703                         if (soap_flag_command2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01704                                 if (soap_in_string(soap, "acq2xx:command", &(((acq2xx__ShellTransaction*)a)->command), "xsd:string"))
01705                                 {       soap_flag_command2--;
01706                                         continue;
01707                                 }
01708                         if (soap_flag_result2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01709                                 if (soap_in_string(soap, "acq2xx:result", &(((acq2xx__ShellTransaction*)a)->result), "xsd:string"))
01710                                 {       soap_flag_result2--;
01711                                         continue;
01712                                 }
01713                         /* transient acq2xx__ShellTransaction skipped */
01714                         /* transient acq2xx__ShellTransaction skipped */
01715                         /* transient ~acq2xx__ShellTransaction skipped */
01716                         /* transient getCommand skipped */
01717                         /* transient getResult skipped */
01718                         /* transient print skipped */
01719                         /* transient initCommand skipped */
01720                         /* transient run skipped */
01721                         if (soap_flag_channels1 && soap->error == SOAP_TAG_MISMATCH)
01722                                 if (soap_in_PointerToacq2xx__GetAvailableChannelsTransaction(soap, "acq2xx:channels", &(((acq2xx__GetVRangeTransaction*)a)->channels), "acq2xx:GetAvailableChannelsTransaction"))
01723                                 {       soap_flag_channels1--;
01724                                         continue;
01725                                 }
01726                         if (soap_flag_ranges1 && soap->error == SOAP_TAG_MISMATCH)
01727                                 if (soap_in_VRangeData(soap, "acq2xx:ranges", &(((acq2xx__GetVRangeTransaction*)a)->ranges), "VRange"))
01728                                 {       soap_flag_ranges1--;
01729                                         continue;
01730                                 }
01731                         /* transient acq2xx__GetVRangeTransaction skipped */
01732                         /* non-serializable getVRange skipped */
01733                         /* transient run skipped */
01734                         if (soap->error == SOAP_TAG_MISMATCH)
01735                                 soap->error = soap_ignore_element(soap);
01736                         if (soap->error == SOAP_NO_TAG)
01737                                 break;
01738                         if (soap->error)
01739                                 return NULL;
01740                 }
01741                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error3 > 0 || soap_flag_status3 > 0 || soap_flag_complete3 > 0 || soap_flag_ranges1 > 0))
01742                 {       soap->error = SOAP_OCCURS;
01743                         return NULL;
01744                 }
01745                 if (soap_element_end_in(soap, tag))
01746                         return NULL;
01747         }
01748         else
01749         {       a = (acq2xx__GetVRangeTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__GetVRangeTransaction, 0, sizeof(acq2xx__GetVRangeTransaction), 0, soap_copy_acq2xx__GetVRangeTransaction);
01750                 if (soap->body && soap_element_end_in(soap, tag))
01751                         return NULL;
01752         }
01753         return a;
01754 }
01755 
01756 SOAP_FMAC5 acq2xx__GetVRangeTransaction * SOAP_FMAC6 soap_new_acq2xx__GetVRangeTransaction(struct soap *soap, int n)
01757 {       return soap_instantiate_acq2xx__GetVRangeTransaction(soap, n, NULL, NULL, NULL);
01758 }
01759 
01760 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__GetVRangeTransaction(struct soap *soap, acq2xx__GetVRangeTransaction *p)
01761 {       soap_delete(soap, p);
01762 }
01763 
01764 SOAP_FMAC3 acq2xx__GetVRangeTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__GetVRangeTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
01765 {
01766         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__GetVRangeTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
01767         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__GetVRangeTransaction, n, soap_fdelete);
01768         if (!cp)
01769                 return NULL;
01770         if (n < 0)
01771         {       cp->ptr = (void*)new acq2xx__GetVRangeTransaction;
01772                 if (size)
01773                         *size = sizeof(acq2xx__GetVRangeTransaction);
01774         }
01775         else
01776         {       cp->ptr = (void*)new acq2xx__GetVRangeTransaction[n];
01777                 if (size)
01778                         *size = n * sizeof(acq2xx__GetVRangeTransaction);
01779         }
01780                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
01781         return (acq2xx__GetVRangeTransaction*)cp->ptr;
01782 }
01783 
01784 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__GetVRangeTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
01785 {
01786         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__GetVRangeTransaction %p -> %p\n", q, p));
01787         *(acq2xx__GetVRangeTransaction*)p = *(acq2xx__GetVRangeTransaction*)q;
01788 }
01789 
01790 void acq2xx__GetAvailableChannelsTransaction::soap_serialize(struct soap *soap) const
01791 {
01792         (void)soap; /* appease -Wall -Werror */
01793         /* transient acq2xx__GetAvailableChannelsTransaction skipped */
01794         /* transient run skipped */
01795         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->command);
01796         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->result);
01797         /* transient acq2xx__ShellTransaction skipped */
01798         /* transient acq2xx__ShellTransaction skipped */
01799         /* transient ~acq2xx__ShellTransaction skipped */
01800         /* transient getCommand skipped */
01801         /* transient getResult skipped */
01802         /* transient print skipped */
01803         /* transient initCommand skipped */
01804         /* transient run skipped */
01805         /* transient acq2xx__Transaction skipped */
01806         /* transient acq2xx__Transaction skipped */
01807         /* transient ~acq2xx__Transaction skipped */
01808         /* transient print skipped */
01809         /* transient exec skipped */
01810         /* transient getCommand skipped */
01811         /* transient getResult skipped */
01812         /* transient run skipped */
01813         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
01814         /* transient acq2xx__Object skipped */
01815         /* transient acq2xx__Object skipped */
01816         /* transient ~acq2xx__Object skipped */
01817         /* transient print skipped */
01818         /* transient getName skipped */
01819 }
01820 
01821 void acq2xx__GetAvailableChannelsTransaction::soap_default(struct soap *soap)
01822 {
01823         (void)soap; /* appease -Wall -Werror */
01824         soap_default_int(soap, &((acq2xx__GetAvailableChannelsTransaction*)this)->AI);
01825         soap_default_int(soap, &((acq2xx__GetAvailableChannelsTransaction*)this)->AO);
01826         /* transient acq2xx__GetAvailableChannelsTransaction skipped */
01827         /* transient run skipped */
01828         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->command);
01829         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->result);
01830         /* transient acq2xx__ShellTransaction skipped */
01831         /* transient acq2xx__ShellTransaction skipped */
01832         /* transient ~acq2xx__ShellTransaction skipped */
01833         /* transient getCommand skipped */
01834         /* transient getResult skipped */
01835         /* transient print skipped */
01836         /* transient initCommand skipped */
01837         /* transient run skipped */
01838         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
01839         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
01840         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
01841         /* transient acq2xx__Transaction skipped */
01842         /* transient acq2xx__Transaction skipped */
01843         /* transient ~acq2xx__Transaction skipped */
01844         /* transient print skipped */
01845         /* transient exec skipped */
01846         /* transient getCommand skipped */
01847         /* transient getResult skipped */
01848         /* transient run skipped */
01849         soap_default_string(soap, &((acq2xx__Object*)this)->name);
01850         /* transient acq2xx__Object skipped */
01851         /* transient acq2xx__Object skipped */
01852         /* transient ~acq2xx__Object skipped */
01853         /* transient print skipped */
01854         /* transient getName skipped */
01855 }
01856 
01857 int acq2xx__GetAvailableChannelsTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
01858 {
01859         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction);
01860         if (this->soap_out(soap, tag, id, type))
01861                 return soap->error;
01862         return soap_putindependent(soap);
01863 }
01864 
01865 int acq2xx__GetAvailableChannelsTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
01866 {
01867         return soap_out_acq2xx__GetAvailableChannelsTransaction(soap, tag, id, this, type);
01868 }
01869 
01870 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__GetAvailableChannelsTransaction(struct soap *soap, const char *tag, int id, const acq2xx__GetAvailableChannelsTransaction *a, const char *type)
01871 {
01872         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction), "acq2xx:GetAvailableChannelsTransaction");
01873         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
01874         /* transient acq2xx__Object skipped */
01875         /* transient acq2xx__Object skipped */
01876         /* transient ~acq2xx__Object skipped */
01877         /* transient print skipped */
01878         /* transient getName skipped */
01879         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
01880         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
01881         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
01882         /* transient acq2xx__Transaction skipped */
01883         /* transient acq2xx__Transaction skipped */
01884         /* transient ~acq2xx__Transaction skipped */
01885         /* transient print skipped */
01886         /* transient exec skipped */
01887         /* transient getCommand skipped */
01888         /* transient getResult skipped */
01889         /* transient run skipped */
01890         soap_out_string(soap, "acq2xx:command", -1, &(((acq2xx__ShellTransaction*)a)->command), "xsd:string");
01891         soap_out_string(soap, "acq2xx:result", -1, &(((acq2xx__ShellTransaction*)a)->result), "xsd:string");
01892         /* transient acq2xx__ShellTransaction skipped */
01893         /* transient acq2xx__ShellTransaction skipped */
01894         /* transient ~acq2xx__ShellTransaction skipped */
01895         /* transient getCommand skipped */
01896         /* transient getResult skipped */
01897         /* transient print skipped */
01898         /* transient initCommand skipped */
01899         /* transient run skipped */
01900         soap_out_int(soap, "acq2xx:AI", -1, &(((acq2xx__GetAvailableChannelsTransaction*)a)->AI), "xsd:int");
01901         soap_out_int(soap, "acq2xx:AO", -1, &(((acq2xx__GetAvailableChannelsTransaction*)a)->AO), "xsd:int");
01902         /* transient acq2xx__GetAvailableChannelsTransaction skipped */
01903         /* transient run skipped */
01904         soap_element_end_out(soap, tag);
01905         return SOAP_OK;
01906 }
01907 
01908 void *acq2xx__GetAvailableChannelsTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
01909 {
01910         return soap_get_acq2xx__GetAvailableChannelsTransaction(soap, this, tag, type);
01911 }
01912 
01913 SOAP_FMAC3 acq2xx__GetAvailableChannelsTransaction * SOAP_FMAC4 soap_get_acq2xx__GetAvailableChannelsTransaction(struct soap *soap, acq2xx__GetAvailableChannelsTransaction *p, const char *tag, const char *type)
01914 {
01915         if ((p = soap_in_acq2xx__GetAvailableChannelsTransaction(soap, tag, p, type)))
01916                 soap_getindependent(soap);
01917         return p;
01918 }
01919 
01920 void *acq2xx__GetAvailableChannelsTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
01921 {       return soap_in_acq2xx__GetAvailableChannelsTransaction(soap, tag, this, type);
01922 }
01923 
01924 SOAP_FMAC3 acq2xx__GetAvailableChannelsTransaction * SOAP_FMAC4 soap_in_acq2xx__GetAvailableChannelsTransaction(struct soap *soap, const char *tag, acq2xx__GetAvailableChannelsTransaction *a, const char *type)
01925 {
01926         if (soap_element_begin_in(soap, tag, 0, NULL))
01927                 return NULL;
01928         a = (acq2xx__GetAvailableChannelsTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction, sizeof(acq2xx__GetAvailableChannelsTransaction), soap->type, soap->arrayType);
01929         if (!a)
01930                 return NULL;
01931         if (soap->alloced)
01932         {       a->soap_default(soap);
01933                 if (soap->clist->type != SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction)
01934                 {       soap_revert(soap);
01935                         *soap->id = '\0';
01936                         return (acq2xx__GetAvailableChannelsTransaction *)a->soap_in(soap, tag, type);
01937                 }
01938         }
01939         short soap_flag_name4 = 1, soap_flag_abort_on_error3 = 1, soap_flag_status3 = 1, soap_flag_complete3 = 1, soap_flag_command2 = 1, soap_flag_result2 = 1, soap_flag_AI1 = 1, soap_flag_AO1 = 1;
01940         if (soap->body && !*soap->href)
01941         {
01942                 for (;;)
01943                 {       soap->error = SOAP_TAG_MISMATCH;
01944                         if (soap_flag_name4 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01945                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
01946                                 {       soap_flag_name4--;
01947                                         continue;
01948                                 }
01949                         /* transient acq2xx__Object skipped */
01950                         /* transient acq2xx__Object skipped */
01951                         /* transient ~acq2xx__Object skipped */
01952                         /* transient print skipped */
01953                         /* transient getName skipped */
01954                         if (soap_flag_abort_on_error3 && soap->error == SOAP_TAG_MISMATCH)
01955                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
01956                                 {       soap_flag_abort_on_error3--;
01957                                         continue;
01958                                 }
01959                         if (soap_flag_status3 && soap->error == SOAP_TAG_MISMATCH)
01960                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
01961                                 {       soap_flag_status3--;
01962                                         continue;
01963                                 }
01964                         if (soap_flag_complete3 && soap->error == SOAP_TAG_MISMATCH)
01965                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
01966                                 {       soap_flag_complete3--;
01967                                         continue;
01968                                 }
01969                         /* transient acq2xx__Transaction skipped */
01970                         /* transient acq2xx__Transaction skipped */
01971                         /* transient ~acq2xx__Transaction skipped */
01972                         /* transient print skipped */
01973                         /* transient exec skipped */
01974                         /* transient getCommand skipped */
01975                         /* transient getResult skipped */
01976                         /* transient run skipped */
01977                         if (soap_flag_command2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01978                                 if (soap_in_string(soap, "acq2xx:command", &(((acq2xx__ShellTransaction*)a)->command), "xsd:string"))
01979                                 {       soap_flag_command2--;
01980                                         continue;
01981                                 }
01982                         if (soap_flag_result2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
01983                                 if (soap_in_string(soap, "acq2xx:result", &(((acq2xx__ShellTransaction*)a)->result), "xsd:string"))
01984                                 {       soap_flag_result2--;
01985                                         continue;
01986                                 }
01987                         /* transient acq2xx__ShellTransaction skipped */
01988                         /* transient acq2xx__ShellTransaction skipped */
01989                         /* transient ~acq2xx__ShellTransaction skipped */
01990                         /* transient getCommand skipped */
01991                         /* transient getResult skipped */
01992                         /* transient print skipped */
01993                         /* transient initCommand skipped */
01994                         /* transient run skipped */
01995                         if (soap_flag_AI1 && soap->error == SOAP_TAG_MISMATCH)
01996                                 if (soap_in_int(soap, "acq2xx:AI", &(((acq2xx__GetAvailableChannelsTransaction*)a)->AI), "xsd:int"))
01997                                 {       soap_flag_AI1--;
01998                                         continue;
01999                                 }
02000                         if (soap_flag_AO1 && soap->error == SOAP_TAG_MISMATCH)
02001                                 if (soap_in_int(soap, "acq2xx:AO", &(((acq2xx__GetAvailableChannelsTransaction*)a)->AO), "xsd:int"))
02002                                 {       soap_flag_AO1--;
02003                                         continue;
02004                                 }
02005                         /* transient acq2xx__GetAvailableChannelsTransaction skipped */
02006                         /* transient run skipped */
02007                         if (soap->error == SOAP_TAG_MISMATCH)
02008                                 soap->error = soap_ignore_element(soap);
02009                         if (soap->error == SOAP_NO_TAG)
02010                                 break;
02011                         if (soap->error)
02012                                 return NULL;
02013                 }
02014                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error3 > 0 || soap_flag_status3 > 0 || soap_flag_complete3 > 0 || soap_flag_AI1 > 0 || soap_flag_AO1 > 0))
02015                 {       soap->error = SOAP_OCCURS;
02016                         return NULL;
02017                 }
02018                 if (soap_element_end_in(soap, tag))
02019                         return NULL;
02020         }
02021         else
02022         {       a = (acq2xx__GetAvailableChannelsTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction, 0, sizeof(acq2xx__GetAvailableChannelsTransaction), 0, soap_copy_acq2xx__GetAvailableChannelsTransaction);
02023                 if (soap->body && soap_element_end_in(soap, tag))
02024                         return NULL;
02025         }
02026         return a;
02027 }
02028 
02029 SOAP_FMAC5 acq2xx__GetAvailableChannelsTransaction * SOAP_FMAC6 soap_new_acq2xx__GetAvailableChannelsTransaction(struct soap *soap, int n)
02030 {       return soap_instantiate_acq2xx__GetAvailableChannelsTransaction(soap, n, NULL, NULL, NULL);
02031 }
02032 
02033 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__GetAvailableChannelsTransaction(struct soap *soap, acq2xx__GetAvailableChannelsTransaction *p)
02034 {       soap_delete(soap, p);
02035 }
02036 
02037 SOAP_FMAC3 acq2xx__GetAvailableChannelsTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__GetAvailableChannelsTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
02038 {
02039         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__GetAvailableChannelsTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
02040         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction, n, soap_fdelete);
02041         if (!cp)
02042                 return NULL;
02043         if (n < 0)
02044         {       cp->ptr = (void*)new acq2xx__GetAvailableChannelsTransaction;
02045                 if (size)
02046                         *size = sizeof(acq2xx__GetAvailableChannelsTransaction);
02047         }
02048         else
02049         {       cp->ptr = (void*)new acq2xx__GetAvailableChannelsTransaction[n];
02050                 if (size)
02051                         *size = n * sizeof(acq2xx__GetAvailableChannelsTransaction);
02052         }
02053                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
02054         return (acq2xx__GetAvailableChannelsTransaction*)cp->ptr;
02055 }
02056 
02057 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__GetAvailableChannelsTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
02058 {
02059         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__GetAvailableChannelsTransaction %p -> %p\n", q, p));
02060         *(acq2xx__GetAvailableChannelsTransaction*)p = *(acq2xx__GetAvailableChannelsTransaction*)q;
02061 }
02062 
02063 void acq2xx__AcqControlTransaction::soap_serialize(struct soap *soap) const
02064 {
02065         if (this->__ptr && !soap_array_reference(soap, this, (struct soap_array*)&this->__ptr, 1, SOAP_TYPE_acq2xx__AcqControlTransaction))
02066                 for (int i = 0; i < this->__size; i++)
02067                 {
02068                         soap_serialize_PointerToacq2xx__Transaction(soap, this->__ptr + i);
02069                 }
02070 }
02071 
02072 void acq2xx__AcqControlTransaction::soap_default(struct soap *soap)
02073 {
02074         this->__size = 0;
02075         this->__ptr = NULL;
02076 }
02077 
02078 int acq2xx__AcqControlTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
02079 {
02080         register int id = soap_embed(soap, (void*)this, (struct soap_array*)&this->__ptr, 1, tag, SOAP_TYPE_acq2xx__AcqControlTransaction);
02081         if (this->soap_out(soap, tag, id, type))
02082                 return soap->error;
02083         return soap_putindependent(soap);
02084 }
02085 
02086 int acq2xx__AcqControlTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
02087 {       return soap_out_acq2xx__AcqControlTransaction(soap, tag, id, this, type);
02088 }
02089 
02090 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__AcqControlTransaction(struct soap *soap, const char *tag, int id, const acq2xx__AcqControlTransaction *a, const char *type)
02091 {
02092         int i, n = a->__size;
02093         id = soap_element_id(soap, tag, id, a, (struct soap_array*)&a->__ptr, 1, type, SOAP_TYPE_acq2xx__AcqControlTransaction);
02094         if (id < 0)
02095                 return soap->error;
02096         soap_element_begin_out(soap, tag, id, "acq2xx:AcqControlTransaction");
02097         for (i = 0; i < n; i++)
02098         {
02099                 soap_out_PointerToacq2xx__Transaction(soap, "acq2xx:item", -1, &a->__ptr[i], "acq2xx:Transaction");
02100         }
02101         soap_element_end_out(soap, tag);
02102         return SOAP_OK;
02103 }
02104 
02105 void *acq2xx__AcqControlTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
02106 {
02107         return soap_get_acq2xx__AcqControlTransaction(soap, this, tag, type);
02108 }
02109 
02110 SOAP_FMAC3 acq2xx__AcqControlTransaction * SOAP_FMAC4 soap_get_acq2xx__AcqControlTransaction(struct soap *soap, acq2xx__AcqControlTransaction *p, const char *tag, const char *type)
02111 {
02112         if ((p = soap_in_acq2xx__AcqControlTransaction(soap, tag, p, type)))
02113                 soap_getindependent(soap);
02114         return p;
02115 }
02116 
02117 void *acq2xx__AcqControlTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
02118 {       return soap_in_acq2xx__AcqControlTransaction(soap, tag, this, type);
02119 }
02120 
02121 SOAP_FMAC3 acq2xx__AcqControlTransaction * SOAP_FMAC4 soap_in_acq2xx__AcqControlTransaction(struct soap *soap, const char *tag, acq2xx__AcqControlTransaction *a, const char *type)
02122 {       int i, j;
02123         acq2xx__Transaction **p;
02124         if (soap_element_begin_in(soap, tag, 1, NULL))
02125                 return NULL;
02126         if (*soap->type && soap_match_tag(soap, soap->type, type))
02127         {       soap->error = SOAP_TYPE;
02128                 return NULL;
02129         }
02130         a = (acq2xx__AcqControlTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__AcqControlTransaction, sizeof(acq2xx__AcqControlTransaction), soap->type, soap->arrayType);
02131         if (!a)
02132                 return NULL;
02133         if (soap->alloced)
02134                 a->soap_default(soap);
02135         if (soap->body && !*soap->href)
02136         {
02137                 a->__size = soap_getsize(soap->arraySize, soap->arrayOffset, &j);
02138                 if (a->__size >= 0)
02139                 {       a->__ptr = (acq2xx__Transaction **)soap_malloc(soap, sizeof(acq2xx__Transaction *) * a->__size);
02140                         for (i = 0; i < a->__size; i++)
02141                                 a->__ptr[i] = NULL;
02142                         for (i = 0; i < a->__size; i++)
02143                         {       soap_peek_element(soap);
02144                                 if (soap->position)
02145                                 {       i = soap->positions[0]-j;
02146                                         if (i < 0 || i >= a->__size)
02147                                         {       soap->error = SOAP_IOB;
02148                                                 return NULL;
02149                                         }
02150                                 }
02151                                 if (!soap_in_PointerToacq2xx__Transaction(soap, NULL, a->__ptr + i, "acq2xx:Transaction"))
02152                                 {       if (soap->error != SOAP_NO_TAG)
02153                                                 return NULL;
02154                                         soap->error = SOAP_OK;
02155                                         break;
02156                                 }
02157                         }
02158                 }
02159                 else
02160                 {       soap_new_block(soap);
02161                         for (a->__size = 0; ; a->__size++)
02162                         {       p = (acq2xx__Transaction **)soap_push_block(soap, sizeof(acq2xx__Transaction *));
02163                                 if (!p)
02164                                         return NULL;
02165                                 *p = NULL;
02166                                 if (!soap_in_PointerToacq2xx__Transaction(soap, NULL, p, "acq2xx:Transaction"))
02167                                 {       if (soap->error != SOAP_NO_TAG)
02168                                                 return NULL;
02169                                         soap->error = SOAP_OK;
02170                                         break;
02171                                 }
02172                         }
02173                         soap_pop_block(soap);
02174                         a->__ptr = (acq2xx__Transaction **)soap_malloc(soap, soap->blist->size);
02175                         soap_save_block(soap, (char*)a->__ptr, 1);
02176                 }
02177                 if (soap_element_end_in(soap, tag))
02178                         return NULL;
02179         }
02180         else
02181         {       a = (acq2xx__AcqControlTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__AcqControlTransaction, 0, sizeof(acq2xx__AcqControlTransaction), 0, soap_copy_acq2xx__AcqControlTransaction);
02182                 if (soap->body && soap_element_end_in(soap, tag))
02183                         return NULL;
02184         }
02185         return a;
02186 }
02187 
02188 SOAP_FMAC5 acq2xx__AcqControlTransaction * SOAP_FMAC6 soap_new_acq2xx__AcqControlTransaction(struct soap *soap, int n)
02189 {       return soap_instantiate_acq2xx__AcqControlTransaction(soap, n, NULL, NULL, NULL);
02190 }
02191 
02192 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__AcqControlTransaction(struct soap *soap, acq2xx__AcqControlTransaction *p)
02193 {       soap_delete(soap, p);
02194 }
02195 
02196 SOAP_FMAC3 acq2xx__AcqControlTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__AcqControlTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
02197 {
02198         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__AcqControlTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
02199         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__AcqControlTransaction, n, soap_fdelete);
02200         if (!cp)
02201                 return NULL;
02202         if (n < 0)
02203         {       cp->ptr = (void*)new acq2xx__AcqControlTransaction;
02204                 if (size)
02205                         *size = sizeof(acq2xx__AcqControlTransaction);
02206         }
02207         else
02208         {       cp->ptr = (void*)new acq2xx__AcqControlTransaction[n];
02209                 if (size)
02210                         *size = n * sizeof(acq2xx__AcqControlTransaction);
02211         }
02212                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
02213         return (acq2xx__AcqControlTransaction*)cp->ptr;
02214 }
02215 
02216 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__AcqControlTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
02217 {
02218         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__AcqControlTransaction %p -> %p\n", q, p));
02219         *(acq2xx__AcqControlTransaction*)p = *(acq2xx__AcqControlTransaction*)q;
02220 }
02221 
02222 void acq2xx__SignalSetTransaction::soap_serialize(struct soap *soap) const
02223 {
02224         (void)soap; /* appease -Wall -Werror */
02225         soap_serialize_string(soap, &((acq2xx__SignalSetTransaction*)this)->signal);
02226         /* transient run skipped */
02227         /* transient acq2xx__SignalSetTransaction skipped */
02228         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->command);
02229         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->result);
02230         /* transient acq2xx__ShellTransaction skipped */
02231         /* transient acq2xx__ShellTransaction skipped */
02232         /* transient ~acq2xx__ShellTransaction skipped */
02233         /* transient getCommand skipped */
02234         /* transient getResult skipped */
02235         /* transient print skipped */
02236         /* transient initCommand skipped */
02237         /* transient run skipped */
02238         /* transient acq2xx__Transaction skipped */
02239         /* transient acq2xx__Transaction skipped */
02240         /* transient ~acq2xx__Transaction skipped */
02241         /* transient print skipped */
02242         /* transient exec skipped */
02243         /* transient getCommand skipped */
02244         /* transient getResult skipped */
02245         /* transient run skipped */
02246         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
02247         /* transient acq2xx__Object skipped */
02248         /* transient acq2xx__Object skipped */
02249         /* transient ~acq2xx__Object skipped */
02250         /* transient print skipped */
02251         /* transient getName skipped */
02252 }
02253 
02254 void acq2xx__SignalSetTransaction::soap_default(struct soap *soap)
02255 {
02256         (void)soap; /* appease -Wall -Werror */
02257         soap_default_string(soap, &((acq2xx__SignalSetTransaction*)this)->signal);
02258         soap_default_acq2xx__DIx(soap, &((acq2xx__SignalSetTransaction*)this)->dix);
02259         soap_default_acq2xx__EDGE(soap, &((acq2xx__SignalSetTransaction*)this)->edge);
02260         /* transient run skipped */
02261         /* transient acq2xx__SignalSetTransaction skipped */
02262         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->command);
02263         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->result);
02264         /* transient acq2xx__ShellTransaction skipped */
02265         /* transient acq2xx__ShellTransaction skipped */
02266         /* transient ~acq2xx__ShellTransaction skipped */
02267         /* transient getCommand skipped */
02268         /* transient getResult skipped */
02269         /* transient print skipped */
02270         /* transient initCommand skipped */
02271         /* transient run skipped */
02272         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
02273         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
02274         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
02275         /* transient acq2xx__Transaction skipped */
02276         /* transient acq2xx__Transaction skipped */
02277         /* transient ~acq2xx__Transaction skipped */
02278         /* transient print skipped */
02279         /* transient exec skipped */
02280         /* transient getCommand skipped */
02281         /* transient getResult skipped */
02282         /* transient run skipped */
02283         soap_default_string(soap, &((acq2xx__Object*)this)->name);
02284         /* transient acq2xx__Object skipped */
02285         /* transient acq2xx__Object skipped */
02286         /* transient ~acq2xx__Object skipped */
02287         /* transient print skipped */
02288         /* transient getName skipped */
02289 }
02290 
02291 int acq2xx__SignalSetTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
02292 {
02293         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__SignalSetTransaction);
02294         if (this->soap_out(soap, tag, id, type))
02295                 return soap->error;
02296         return soap_putindependent(soap);
02297 }
02298 
02299 int acq2xx__SignalSetTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
02300 {
02301         return soap_out_acq2xx__SignalSetTransaction(soap, tag, id, this, type);
02302 }
02303 
02304 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__SignalSetTransaction(struct soap *soap, const char *tag, int id, const acq2xx__SignalSetTransaction *a, const char *type)
02305 {
02306         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__SignalSetTransaction), "acq2xx:SignalSetTransaction");
02307         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
02308         /* transient acq2xx__Object skipped */
02309         /* transient acq2xx__Object skipped */
02310         /* transient ~acq2xx__Object skipped */
02311         /* transient print skipped */
02312         /* transient getName skipped */
02313         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
02314         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
02315         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
02316         /* transient acq2xx__Transaction skipped */
02317         /* transient acq2xx__Transaction skipped */
02318         /* transient ~acq2xx__Transaction skipped */
02319         /* transient print skipped */
02320         /* transient exec skipped */
02321         /* transient getCommand skipped */
02322         /* transient getResult skipped */
02323         /* transient run skipped */
02324         soap_out_string(soap, "acq2xx:command", -1, &(((acq2xx__ShellTransaction*)a)->command), "xsd:string");
02325         soap_out_string(soap, "acq2xx:result", -1, &(((acq2xx__ShellTransaction*)a)->result), "xsd:string");
02326         /* transient acq2xx__ShellTransaction skipped */
02327         /* transient acq2xx__ShellTransaction skipped */
02328         /* transient ~acq2xx__ShellTransaction skipped */
02329         /* transient getCommand skipped */
02330         /* transient getResult skipped */
02331         /* transient print skipped */
02332         /* transient initCommand skipped */
02333         /* transient run skipped */
02334         soap_out_string(soap, "acq2xx:signal", -1, &(((acq2xx__SignalSetTransaction*)a)->signal), "xsd:string");
02335         soap_out_acq2xx__DIx(soap, "acq2xx:dix", -1, &(((acq2xx__SignalSetTransaction*)a)->dix), "acq2xx:DIx");
02336         soap_out_acq2xx__EDGE(soap, "acq2xx:edge", -1, &(((acq2xx__SignalSetTransaction*)a)->edge), "acq2xx:EDGE");
02337         /* transient run skipped */
02338         /* transient acq2xx__SignalSetTransaction skipped */
02339         soap_element_end_out(soap, tag);
02340         return SOAP_OK;
02341 }
02342 
02343 void *acq2xx__SignalSetTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
02344 {
02345         return soap_get_acq2xx__SignalSetTransaction(soap, this, tag, type);
02346 }
02347 
02348 SOAP_FMAC3 acq2xx__SignalSetTransaction * SOAP_FMAC4 soap_get_acq2xx__SignalSetTransaction(struct soap *soap, acq2xx__SignalSetTransaction *p, const char *tag, const char *type)
02349 {
02350         if ((p = soap_in_acq2xx__SignalSetTransaction(soap, tag, p, type)))
02351                 soap_getindependent(soap);
02352         return p;
02353 }
02354 
02355 void *acq2xx__SignalSetTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
02356 {       return soap_in_acq2xx__SignalSetTransaction(soap, tag, this, type);
02357 }
02358 
02359 SOAP_FMAC3 acq2xx__SignalSetTransaction * SOAP_FMAC4 soap_in_acq2xx__SignalSetTransaction(struct soap *soap, const char *tag, acq2xx__SignalSetTransaction *a, const char *type)
02360 {
02361         if (soap_element_begin_in(soap, tag, 0, NULL))
02362                 return NULL;
02363         a = (acq2xx__SignalSetTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__SignalSetTransaction, sizeof(acq2xx__SignalSetTransaction), soap->type, soap->arrayType);
02364         if (!a)
02365                 return NULL;
02366         if (soap->alloced)
02367         {       a->soap_default(soap);
02368                 if (soap->clist->type != SOAP_TYPE_acq2xx__SignalSetTransaction)
02369                 {       soap_revert(soap);
02370                         *soap->id = '\0';
02371                         return (acq2xx__SignalSetTransaction *)a->soap_in(soap, tag, type);
02372                 }
02373         }
02374         short soap_flag_name4 = 1, soap_flag_abort_on_error3 = 1, soap_flag_status3 = 1, soap_flag_complete3 = 1, soap_flag_command2 = 1, soap_flag_result2 = 1, soap_flag_signal1 = 1, soap_flag_dix1 = 1, soap_flag_edge1 = 1;
02375         if (soap->body && !*soap->href)
02376         {
02377                 for (;;)
02378                 {       soap->error = SOAP_TAG_MISMATCH;
02379                         if (soap_flag_name4 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02380                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
02381                                 {       soap_flag_name4--;
02382                                         continue;
02383                                 }
02384                         /* transient acq2xx__Object skipped */
02385                         /* transient acq2xx__Object skipped */
02386                         /* transient ~acq2xx__Object skipped */
02387                         /* transient print skipped */
02388                         /* transient getName skipped */
02389                         if (soap_flag_abort_on_error3 && soap->error == SOAP_TAG_MISMATCH)
02390                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
02391                                 {       soap_flag_abort_on_error3--;
02392                                         continue;
02393                                 }
02394                         if (soap_flag_status3 && soap->error == SOAP_TAG_MISMATCH)
02395                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
02396                                 {       soap_flag_status3--;
02397                                         continue;
02398                                 }
02399                         if (soap_flag_complete3 && soap->error == SOAP_TAG_MISMATCH)
02400                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
02401                                 {       soap_flag_complete3--;
02402                                         continue;
02403                                 }
02404                         /* transient acq2xx__Transaction skipped */
02405                         /* transient acq2xx__Transaction skipped */
02406                         /* transient ~acq2xx__Transaction skipped */
02407                         /* transient print skipped */
02408                         /* transient exec skipped */
02409                         /* transient getCommand skipped */
02410                         /* transient getResult skipped */
02411                         /* transient run skipped */
02412                         if (soap_flag_command2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02413                                 if (soap_in_string(soap, "acq2xx:command", &(((acq2xx__ShellTransaction*)a)->command), "xsd:string"))
02414                                 {       soap_flag_command2--;
02415                                         continue;
02416                                 }
02417                         if (soap_flag_result2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02418                                 if (soap_in_string(soap, "acq2xx:result", &(((acq2xx__ShellTransaction*)a)->result), "xsd:string"))
02419                                 {       soap_flag_result2--;
02420                                         continue;
02421                                 }
02422                         /* transient acq2xx__ShellTransaction skipped */
02423                         /* transient acq2xx__ShellTransaction skipped */
02424                         /* transient ~acq2xx__ShellTransaction skipped */
02425                         /* transient getCommand skipped */
02426                         /* transient getResult skipped */
02427                         /* transient print skipped */
02428                         /* transient initCommand skipped */
02429                         /* transient run skipped */
02430                         if (soap_flag_signal1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02431                                 if (soap_in_string(soap, "acq2xx:signal", &(((acq2xx__SignalSetTransaction*)a)->signal), "xsd:string"))
02432                                 {       soap_flag_signal1--;
02433                                         continue;
02434                                 }
02435                         if (soap_flag_dix1 && soap->error == SOAP_TAG_MISMATCH)
02436                                 if (soap_in_acq2xx__DIx(soap, "acq2xx:dix", &(((acq2xx__SignalSetTransaction*)a)->dix), "acq2xx:DIx"))
02437                                 {       soap_flag_dix1--;
02438                                         continue;
02439                                 }
02440                         if (soap_flag_edge1 && soap->error == SOAP_TAG_MISMATCH)
02441                                 if (soap_in_acq2xx__EDGE(soap, "acq2xx:edge", &(((acq2xx__SignalSetTransaction*)a)->edge), "acq2xx:EDGE"))
02442                                 {       soap_flag_edge1--;
02443                                         continue;
02444                                 }
02445                         /* transient run skipped */
02446                         /* transient acq2xx__SignalSetTransaction skipped */
02447                         if (soap->error == SOAP_TAG_MISMATCH)
02448                                 soap->error = soap_ignore_element(soap);
02449                         if (soap->error == SOAP_NO_TAG)
02450                                 break;
02451                         if (soap->error)
02452                                 return NULL;
02453                 }
02454                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error3 > 0 || soap_flag_status3 > 0 || soap_flag_complete3 > 0 || soap_flag_dix1 > 0 || soap_flag_edge1 > 0))
02455                 {       soap->error = SOAP_OCCURS;
02456                         return NULL;
02457                 }
02458                 if (soap_element_end_in(soap, tag))
02459                         return NULL;
02460         }
02461         else
02462         {       a = (acq2xx__SignalSetTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__SignalSetTransaction, 0, sizeof(acq2xx__SignalSetTransaction), 0, soap_copy_acq2xx__SignalSetTransaction);
02463                 if (soap->body && soap_element_end_in(soap, tag))
02464                         return NULL;
02465         }
02466         return a;
02467 }
02468 
02469 SOAP_FMAC5 acq2xx__SignalSetTransaction * SOAP_FMAC6 soap_new_acq2xx__SignalSetTransaction(struct soap *soap, int n)
02470 {       return soap_instantiate_acq2xx__SignalSetTransaction(soap, n, NULL, NULL, NULL);
02471 }
02472 
02473 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__SignalSetTransaction(struct soap *soap, acq2xx__SignalSetTransaction *p)
02474 {       soap_delete(soap, p);
02475 }
02476 
02477 SOAP_FMAC3 acq2xx__SignalSetTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__SignalSetTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
02478 {
02479         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__SignalSetTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
02480         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__SignalSetTransaction, n, soap_fdelete);
02481         if (!cp)
02482                 return NULL;
02483         if (n < 0)
02484         {       cp->ptr = (void*)new acq2xx__SignalSetTransaction;
02485                 if (size)
02486                         *size = sizeof(acq2xx__SignalSetTransaction);
02487         }
02488         else
02489         {       cp->ptr = (void*)new acq2xx__SignalSetTransaction[n];
02490                 if (size)
02491                         *size = n * sizeof(acq2xx__SignalSetTransaction);
02492         }
02493                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
02494         return (acq2xx__SignalSetTransaction*)cp->ptr;
02495 }
02496 
02497 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__SignalSetTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
02498 {
02499         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__SignalSetTransaction %p -> %p\n", q, p));
02500         *(acq2xx__SignalSetTransaction*)p = *(acq2xx__SignalSetTransaction*)q;
02501 }
02502 
02503 void acq2xx__ExternalClockSetTransaction::soap_serialize(struct soap *soap) const
02504 {
02505         (void)soap; /* appease -Wall -Werror */
02506         /* transient run skipped */
02507         /* transient acq2xx__ExternalClockSetTransaction skipped */
02508         /* transient acq2xx__ClockSetTransaction skipped */
02509         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->command);
02510         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->result);
02511         /* transient acq2xx__ShellTransaction skipped */
02512         /* transient acq2xx__ShellTransaction skipped */
02513         /* transient ~acq2xx__ShellTransaction skipped */
02514         /* transient getCommand skipped */
02515         /* transient getResult skipped */
02516         /* transient print skipped */
02517         /* transient initCommand skipped */
02518         /* transient run skipped */
02519         /* transient acq2xx__Transaction skipped */
02520         /* transient acq2xx__Transaction skipped */
02521         /* transient ~acq2xx__Transaction skipped */
02522         /* transient print skipped */
02523         /* transient exec skipped */
02524         /* transient getCommand skipped */
02525         /* transient getResult skipped */
02526         /* transient run skipped */
02527         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
02528         /* transient acq2xx__Object skipped */
02529         /* transient acq2xx__Object skipped */
02530         /* transient ~acq2xx__Object skipped */
02531         /* transient print skipped */
02532         /* transient getName skipped */
02533 }
02534 
02535 void acq2xx__ExternalClockSetTransaction::soap_default(struct soap *soap)
02536 {
02537         (void)soap; /* appease -Wall -Werror */
02538         soap_default_acq2xx__DIx(soap, &((acq2xx__ExternalClockSetTransaction*)this)->dix);
02539         soap_default_int(soap, &((acq2xx__ExternalClockSetTransaction*)this)->div);
02540         soap_default_acq2xx__DOx(soap, &((acq2xx__ExternalClockSetTransaction*)this)->dox);
02541         /* transient run skipped */
02542         /* transient acq2xx__ExternalClockSetTransaction skipped */
02543         /* transient acq2xx__ClockSetTransaction skipped */
02544         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->command);
02545         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->result);
02546         /* transient acq2xx__ShellTransaction skipped */
02547         /* transient acq2xx__ShellTransaction skipped */
02548         /* transient ~acq2xx__ShellTransaction skipped */
02549         /* transient getCommand skipped */
02550         /* transient getResult skipped */
02551         /* transient print skipped */
02552         /* transient initCommand skipped */
02553         /* transient run skipped */
02554         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
02555         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
02556         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
02557         /* transient acq2xx__Transaction skipped */
02558         /* transient acq2xx__Transaction skipped */
02559         /* transient ~acq2xx__Transaction skipped */
02560         /* transient print skipped */
02561         /* transient exec skipped */
02562         /* transient getCommand skipped */
02563         /* transient getResult skipped */
02564         /* transient run skipped */
02565         soap_default_string(soap, &((acq2xx__Object*)this)->name);
02566         /* transient acq2xx__Object skipped */
02567         /* transient acq2xx__Object skipped */
02568         /* transient ~acq2xx__Object skipped */
02569         /* transient print skipped */
02570         /* transient getName skipped */
02571 }
02572 
02573 int acq2xx__ExternalClockSetTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
02574 {
02575         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__ExternalClockSetTransaction);
02576         if (this->soap_out(soap, tag, id, type))
02577                 return soap->error;
02578         return soap_putindependent(soap);
02579 }
02580 
02581 int acq2xx__ExternalClockSetTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
02582 {
02583         return soap_out_acq2xx__ExternalClockSetTransaction(soap, tag, id, this, type);
02584 }
02585 
02586 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__ExternalClockSetTransaction(struct soap *soap, const char *tag, int id, const acq2xx__ExternalClockSetTransaction *a, const char *type)
02587 {
02588         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__ExternalClockSetTransaction), "acq2xx:ExternalClockSetTransaction");
02589         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
02590         /* transient acq2xx__Object skipped */
02591         /* transient acq2xx__Object skipped */
02592         /* transient ~acq2xx__Object skipped */
02593         /* transient print skipped */
02594         /* transient getName skipped */
02595         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
02596         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
02597         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
02598         /* transient acq2xx__Transaction skipped */
02599         /* transient acq2xx__Transaction skipped */
02600         /* transient ~acq2xx__Transaction skipped */
02601         /* transient print skipped */
02602         /* transient exec skipped */
02603         /* transient getCommand skipped */
02604         /* transient getResult skipped */
02605         /* transient run skipped */
02606         soap_out_string(soap, "acq2xx:command", -1, &(((acq2xx__ShellTransaction*)a)->command), "xsd:string");
02607         soap_out_string(soap, "acq2xx:result", -1, &(((acq2xx__ShellTransaction*)a)->result), "xsd:string");
02608         /* transient acq2xx__ShellTransaction skipped */
02609         /* transient acq2xx__ShellTransaction skipped */
02610         /* transient ~acq2xx__ShellTransaction skipped */
02611         /* transient getCommand skipped */
02612         /* transient getResult skipped */
02613         /* transient print skipped */
02614         /* transient initCommand skipped */
02615         /* transient run skipped */
02616         /* transient acq2xx__ClockSetTransaction skipped */
02617         soap_out_acq2xx__DIx(soap, "acq2xx:dix", -1, &(((acq2xx__ExternalClockSetTransaction*)a)->dix), "acq2xx:DIx");
02618         soap_out_int(soap, "acq2xx:div", -1, &(((acq2xx__ExternalClockSetTransaction*)a)->div), "xsd:int");
02619         soap_out_acq2xx__DOx(soap, "acq2xx:dox", -1, &(((acq2xx__ExternalClockSetTransaction*)a)->dox), "acq2xx:DOx");
02620         /* transient run skipped */
02621         /* transient acq2xx__ExternalClockSetTransaction skipped */
02622         soap_element_end_out(soap, tag);
02623         return SOAP_OK;
02624 }
02625 
02626 void *acq2xx__ExternalClockSetTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
02627 {
02628         return soap_get_acq2xx__ExternalClockSetTransaction(soap, this, tag, type);
02629 }
02630 
02631 SOAP_FMAC3 acq2xx__ExternalClockSetTransaction * SOAP_FMAC4 soap_get_acq2xx__ExternalClockSetTransaction(struct soap *soap, acq2xx__ExternalClockSetTransaction *p, const char *tag, const char *type)
02632 {
02633         if ((p = soap_in_acq2xx__ExternalClockSetTransaction(soap, tag, p, type)))
02634                 soap_getindependent(soap);
02635         return p;
02636 }
02637 
02638 void *acq2xx__ExternalClockSetTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
02639 {       return soap_in_acq2xx__ExternalClockSetTransaction(soap, tag, this, type);
02640 }
02641 
02642 SOAP_FMAC3 acq2xx__ExternalClockSetTransaction * SOAP_FMAC4 soap_in_acq2xx__ExternalClockSetTransaction(struct soap *soap, const char *tag, acq2xx__ExternalClockSetTransaction *a, const char *type)
02643 {
02644         if (soap_element_begin_in(soap, tag, 0, NULL))
02645                 return NULL;
02646         a = (acq2xx__ExternalClockSetTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__ExternalClockSetTransaction, sizeof(acq2xx__ExternalClockSetTransaction), soap->type, soap->arrayType);
02647         if (!a)
02648                 return NULL;
02649         if (soap->alloced)
02650         {       a->soap_default(soap);
02651                 if (soap->clist->type != SOAP_TYPE_acq2xx__ExternalClockSetTransaction)
02652                 {       soap_revert(soap);
02653                         *soap->id = '\0';
02654                         return (acq2xx__ExternalClockSetTransaction *)a->soap_in(soap, tag, type);
02655                 }
02656         }
02657         short soap_flag_name5 = 1, soap_flag_abort_on_error4 = 1, soap_flag_status4 = 1, soap_flag_complete4 = 1, soap_flag_command3 = 1, soap_flag_result3 = 1, soap_flag_dix1 = 1, soap_flag_div1 = 1, soap_flag_dox1 = 1;
02658         if (soap->body && !*soap->href)
02659         {
02660                 for (;;)
02661                 {       soap->error = SOAP_TAG_MISMATCH;
02662                         if (soap_flag_name5 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02663                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
02664                                 {       soap_flag_name5--;
02665                                         continue;
02666                                 }
02667                         /* transient acq2xx__Object skipped */
02668                         /* transient acq2xx__Object skipped */
02669                         /* transient ~acq2xx__Object skipped */
02670                         /* transient print skipped */
02671                         /* transient getName skipped */
02672                         if (soap_flag_abort_on_error4 && soap->error == SOAP_TAG_MISMATCH)
02673                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
02674                                 {       soap_flag_abort_on_error4--;
02675                                         continue;
02676                                 }
02677                         if (soap_flag_status4 && soap->error == SOAP_TAG_MISMATCH)
02678                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
02679                                 {       soap_flag_status4--;
02680                                         continue;
02681                                 }
02682                         if (soap_flag_complete4 && soap->error == SOAP_TAG_MISMATCH)
02683                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
02684                                 {       soap_flag_complete4--;
02685                                         continue;
02686                                 }
02687                         /* transient acq2xx__Transaction skipped */
02688                         /* transient acq2xx__Transaction skipped */
02689                         /* transient ~acq2xx__Transaction skipped */
02690                         /* transient print skipped */
02691                         /* transient exec skipped */
02692                         /* transient getCommand skipped */
02693                         /* transient getResult skipped */
02694                         /* transient run skipped */
02695                         if (soap_flag_command3 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02696                                 if (soap_in_string(soap, "acq2xx:command", &(((acq2xx__ShellTransaction*)a)->command), "xsd:string"))
02697                                 {       soap_flag_command3--;
02698                                         continue;
02699                                 }
02700                         if (soap_flag_result3 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02701                                 if (soap_in_string(soap, "acq2xx:result", &(((acq2xx__ShellTransaction*)a)->result), "xsd:string"))
02702                                 {       soap_flag_result3--;
02703                                         continue;
02704                                 }
02705                         /* transient acq2xx__ShellTransaction skipped */
02706                         /* transient acq2xx__ShellTransaction skipped */
02707                         /* transient ~acq2xx__ShellTransaction skipped */
02708                         /* transient getCommand skipped */
02709                         /* transient getResult skipped */
02710                         /* transient print skipped */
02711                         /* transient initCommand skipped */
02712                         /* transient run skipped */
02713                         /* transient acq2xx__ClockSetTransaction skipped */
02714                         if (soap_flag_dix1 && soap->error == SOAP_TAG_MISMATCH)
02715                                 if (soap_in_acq2xx__DIx(soap, "acq2xx:dix", &(((acq2xx__ExternalClockSetTransaction*)a)->dix), "acq2xx:DIx"))
02716                                 {       soap_flag_dix1--;
02717                                         continue;
02718                                 }
02719                         if (soap_flag_div1 && soap->error == SOAP_TAG_MISMATCH)
02720                                 if (soap_in_int(soap, "acq2xx:div", &(((acq2xx__ExternalClockSetTransaction*)a)->div), "xsd:int"))
02721                                 {       soap_flag_div1--;
02722                                         continue;
02723                                 }
02724                         if (soap_flag_dox1 && soap->error == SOAP_TAG_MISMATCH)
02725                                 if (soap_in_acq2xx__DOx(soap, "acq2xx:dox", &(((acq2xx__ExternalClockSetTransaction*)a)->dox), "acq2xx:DOx"))
02726                                 {       soap_flag_dox1--;
02727                                         continue;
02728                                 }
02729                         /* transient run skipped */
02730                         /* transient acq2xx__ExternalClockSetTransaction skipped */
02731                         if (soap->error == SOAP_TAG_MISMATCH)
02732                                 soap->error = soap_ignore_element(soap);
02733                         if (soap->error == SOAP_NO_TAG)
02734                                 break;
02735                         if (soap->error)
02736                                 return NULL;
02737                 }
02738                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error4 > 0 || soap_flag_status4 > 0 || soap_flag_complete4 > 0 || soap_flag_dix1 > 0 || soap_flag_div1 > 0 || soap_flag_dox1 > 0))
02739                 {       soap->error = SOAP_OCCURS;
02740                         return NULL;
02741                 }
02742                 if (soap_element_end_in(soap, tag))
02743                         return NULL;
02744         }
02745         else
02746         {       a = (acq2xx__ExternalClockSetTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__ExternalClockSetTransaction, 0, sizeof(acq2xx__ExternalClockSetTransaction), 0, soap_copy_acq2xx__ExternalClockSetTransaction);
02747                 if (soap->body && soap_element_end_in(soap, tag))
02748                         return NULL;
02749         }
02750         return a;
02751 }
02752 
02753 SOAP_FMAC5 acq2xx__ExternalClockSetTransaction * SOAP_FMAC6 soap_new_acq2xx__ExternalClockSetTransaction(struct soap *soap, int n)
02754 {       return soap_instantiate_acq2xx__ExternalClockSetTransaction(soap, n, NULL, NULL, NULL);
02755 }
02756 
02757 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__ExternalClockSetTransaction(struct soap *soap, acq2xx__ExternalClockSetTransaction *p)
02758 {       soap_delete(soap, p);
02759 }
02760 
02761 SOAP_FMAC3 acq2xx__ExternalClockSetTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__ExternalClockSetTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
02762 {
02763         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__ExternalClockSetTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
02764         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__ExternalClockSetTransaction, n, soap_fdelete);
02765         if (!cp)
02766                 return NULL;
02767         if (n < 0)
02768         {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction;
02769                 if (size)
02770                         *size = sizeof(acq2xx__ExternalClockSetTransaction);
02771         }
02772         else
02773         {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction[n];
02774                 if (size)
02775                         *size = n * sizeof(acq2xx__ExternalClockSetTransaction);
02776         }
02777                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
02778         return (acq2xx__ExternalClockSetTransaction*)cp->ptr;
02779 }
02780 
02781 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__ExternalClockSetTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
02782 {
02783         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__ExternalClockSetTransaction %p -> %p\n", q, p));
02784         *(acq2xx__ExternalClockSetTransaction*)p = *(acq2xx__ExternalClockSetTransaction*)q;
02785 }
02786 
02787 void acq2xx__InternalClockSetTransaction::soap_serialize(struct soap *soap) const
02788 {
02789         (void)soap; /* appease -Wall -Werror */
02790         /* transient run skipped */
02791         /* transient acq2xx__InternalClockSetTransaction skipped */
02792         /* transient acq2xx__ClockSetTransaction skipped */
02793         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->command);
02794         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->result);
02795         /* transient acq2xx__ShellTransaction skipped */
02796         /* transient acq2xx__ShellTransaction skipped */
02797         /* transient ~acq2xx__ShellTransaction skipped */
02798         /* transient getCommand skipped */
02799         /* transient getResult skipped */
02800         /* transient print skipped */
02801         /* transient initCommand skipped */
02802         /* transient run skipped */
02803         /* transient acq2xx__Transaction skipped */
02804         /* transient acq2xx__Transaction skipped */
02805         /* transient ~acq2xx__Transaction skipped */
02806         /* transient print skipped */
02807         /* transient exec skipped */
02808         /* transient getCommand skipped */
02809         /* transient getResult skipped */
02810         /* transient run skipped */
02811         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
02812         /* transient acq2xx__Object skipped */
02813         /* transient acq2xx__Object skipped */
02814         /* transient ~acq2xx__Object skipped */
02815         /* transient print skipped */
02816         /* transient getName skipped */
02817 }
02818 
02819 void acq2xx__InternalClockSetTransaction::soap_default(struct soap *soap)
02820 {
02821         (void)soap; /* appease -Wall -Werror */
02822         soap_default_int(soap, &((acq2xx__InternalClockSetTransaction*)this)->hz);
02823         soap_default_int(soap, &((acq2xx__InternalClockSetTransaction*)this)->div);
02824         soap_default_acq2xx__DOx(soap, &((acq2xx__InternalClockSetTransaction*)this)->dox);
02825         /* transient run skipped */
02826         /* transient acq2xx__InternalClockSetTransaction skipped */
02827         /* transient acq2xx__ClockSetTransaction skipped */
02828         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->command);
02829         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->result);
02830         /* transient acq2xx__ShellTransaction skipped */
02831         /* transient acq2xx__ShellTransaction skipped */
02832         /* transient ~acq2xx__ShellTransaction skipped */
02833         /* transient getCommand skipped */
02834         /* transient getResult skipped */
02835         /* transient print skipped */
02836         /* transient initCommand skipped */
02837         /* transient run skipped */
02838         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
02839         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
02840         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
02841         /* transient acq2xx__Transaction skipped */
02842         /* transient acq2xx__Transaction skipped */
02843         /* transient ~acq2xx__Transaction skipped */
02844         /* transient print skipped */
02845         /* transient exec skipped */
02846         /* transient getCommand skipped */
02847         /* transient getResult skipped */
02848         /* transient run skipped */
02849         soap_default_string(soap, &((acq2xx__Object*)this)->name);
02850         /* transient acq2xx__Object skipped */
02851         /* transient acq2xx__Object skipped */
02852         /* transient ~acq2xx__Object skipped */
02853         /* transient print skipped */
02854         /* transient getName skipped */
02855 }
02856 
02857 int acq2xx__InternalClockSetTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
02858 {
02859         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__InternalClockSetTransaction);
02860         if (this->soap_out(soap, tag, id, type))
02861                 return soap->error;
02862         return soap_putindependent(soap);
02863 }
02864 
02865 int acq2xx__InternalClockSetTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
02866 {
02867         return soap_out_acq2xx__InternalClockSetTransaction(soap, tag, id, this, type);
02868 }
02869 
02870 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__InternalClockSetTransaction(struct soap *soap, const char *tag, int id, const acq2xx__InternalClockSetTransaction *a, const char *type)
02871 {
02872         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__InternalClockSetTransaction), "acq2xx:InternalClockSetTransaction");
02873         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
02874         /* transient acq2xx__Object skipped */
02875         /* transient acq2xx__Object skipped */
02876         /* transient ~acq2xx__Object skipped */
02877         /* transient print skipped */
02878         /* transient getName skipped */
02879         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
02880         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
02881         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
02882         /* transient acq2xx__Transaction skipped */
02883         /* transient acq2xx__Transaction skipped */
02884         /* transient ~acq2xx__Transaction skipped */
02885         /* transient print skipped */
02886         /* transient exec skipped */
02887         /* transient getCommand skipped */
02888         /* transient getResult skipped */
02889         /* transient run skipped */
02890         soap_out_string(soap, "acq2xx:command", -1, &(((acq2xx__ShellTransaction*)a)->command), "xsd:string");
02891         soap_out_string(soap, "acq2xx:result", -1, &(((acq2xx__ShellTransaction*)a)->result), "xsd:string");
02892         /* transient acq2xx__ShellTransaction skipped */
02893         /* transient acq2xx__ShellTransaction skipped */
02894         /* transient ~acq2xx__ShellTransaction skipped */
02895         /* transient getCommand skipped */
02896         /* transient getResult skipped */
02897         /* transient print skipped */
02898         /* transient initCommand skipped */
02899         /* transient run skipped */
02900         /* transient acq2xx__ClockSetTransaction skipped */
02901         soap_out_int(soap, "acq2xx:hz", -1, &(((acq2xx__InternalClockSetTransaction*)a)->hz), "xsd:int");
02902         soap_out_int(soap, "acq2xx:div", -1, &(((acq2xx__InternalClockSetTransaction*)a)->div), "xsd:int");
02903         soap_out_acq2xx__DOx(soap, "acq2xx:dox", -1, &(((acq2xx__InternalClockSetTransaction*)a)->dox), "acq2xx:DOx");
02904         /* transient run skipped */
02905         /* transient acq2xx__InternalClockSetTransaction skipped */
02906         soap_element_end_out(soap, tag);
02907         return SOAP_OK;
02908 }
02909 
02910 void *acq2xx__InternalClockSetTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
02911 {
02912         return soap_get_acq2xx__InternalClockSetTransaction(soap, this, tag, type);
02913 }
02914 
02915 SOAP_FMAC3 acq2xx__InternalClockSetTransaction * SOAP_FMAC4 soap_get_acq2xx__InternalClockSetTransaction(struct soap *soap, acq2xx__InternalClockSetTransaction *p, const char *tag, const char *type)
02916 {
02917         if ((p = soap_in_acq2xx__InternalClockSetTransaction(soap, tag, p, type)))
02918                 soap_getindependent(soap);
02919         return p;
02920 }
02921 
02922 void *acq2xx__InternalClockSetTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
02923 {       return soap_in_acq2xx__InternalClockSetTransaction(soap, tag, this, type);
02924 }
02925 
02926 SOAP_FMAC3 acq2xx__InternalClockSetTransaction * SOAP_FMAC4 soap_in_acq2xx__InternalClockSetTransaction(struct soap *soap, const char *tag, acq2xx__InternalClockSetTransaction *a, const char *type)
02927 {
02928         if (soap_element_begin_in(soap, tag, 0, NULL))
02929                 return NULL;
02930         a = (acq2xx__InternalClockSetTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__InternalClockSetTransaction, sizeof(acq2xx__InternalClockSetTransaction), soap->type, soap->arrayType);
02931         if (!a)
02932                 return NULL;
02933         if (soap->alloced)
02934         {       a->soap_default(soap);
02935                 if (soap->clist->type != SOAP_TYPE_acq2xx__InternalClockSetTransaction)
02936                 {       soap_revert(soap);
02937                         *soap->id = '\0';
02938                         return (acq2xx__InternalClockSetTransaction *)a->soap_in(soap, tag, type);
02939                 }
02940         }
02941         short soap_flag_name5 = 1, soap_flag_abort_on_error4 = 1, soap_flag_status4 = 1, soap_flag_complete4 = 1, soap_flag_command3 = 1, soap_flag_result3 = 1, soap_flag_hz1 = 1, soap_flag_div1 = 1, soap_flag_dox1 = 1;
02942         if (soap->body && !*soap->href)
02943         {
02944                 for (;;)
02945                 {       soap->error = SOAP_TAG_MISMATCH;
02946                         if (soap_flag_name5 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02947                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
02948                                 {       soap_flag_name5--;
02949                                         continue;
02950                                 }
02951                         /* transient acq2xx__Object skipped */
02952                         /* transient acq2xx__Object skipped */
02953                         /* transient ~acq2xx__Object skipped */
02954                         /* transient print skipped */
02955                         /* transient getName skipped */
02956                         if (soap_flag_abort_on_error4 && soap->error == SOAP_TAG_MISMATCH)
02957                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
02958                                 {       soap_flag_abort_on_error4--;
02959                                         continue;
02960                                 }
02961                         if (soap_flag_status4 && soap->error == SOAP_TAG_MISMATCH)
02962                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
02963                                 {       soap_flag_status4--;
02964                                         continue;
02965                                 }
02966                         if (soap_flag_complete4 && soap->error == SOAP_TAG_MISMATCH)
02967                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
02968                                 {       soap_flag_complete4--;
02969                                         continue;
02970                                 }
02971                         /* transient acq2xx__Transaction skipped */
02972                         /* transient acq2xx__Transaction skipped */
02973                         /* transient ~acq2xx__Transaction skipped */
02974                         /* transient print skipped */
02975                         /* transient exec skipped */
02976                         /* transient getCommand skipped */
02977                         /* transient getResult skipped */
02978                         /* transient run skipped */
02979                         if (soap_flag_command3 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02980                                 if (soap_in_string(soap, "acq2xx:command", &(((acq2xx__ShellTransaction*)a)->command), "xsd:string"))
02981                                 {       soap_flag_command3--;
02982                                         continue;
02983                                 }
02984                         if (soap_flag_result3 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
02985                                 if (soap_in_string(soap, "acq2xx:result", &(((acq2xx__ShellTransaction*)a)->result), "xsd:string"))
02986                                 {       soap_flag_result3--;
02987                                         continue;
02988                                 }
02989                         /* transient acq2xx__ShellTransaction skipped */
02990                         /* transient acq2xx__ShellTransaction skipped */
02991                         /* transient ~acq2xx__ShellTransaction skipped */
02992                         /* transient getCommand skipped */
02993                         /* transient getResult skipped */
02994                         /* transient print skipped */
02995                         /* transient initCommand skipped */
02996                         /* transient run skipped */
02997                         /* transient acq2xx__ClockSetTransaction skipped */
02998                         if (soap_flag_hz1 && soap->error == SOAP_TAG_MISMATCH)
02999                                 if (soap_in_int(soap, "acq2xx:hz", &(((acq2xx__InternalClockSetTransaction*)a)->hz), "xsd:int"))
03000                                 {       soap_flag_hz1--;
03001                                         continue;
03002                                 }
03003                         if (soap_flag_div1 && soap->error == SOAP_TAG_MISMATCH)
03004                                 if (soap_in_int(soap, "acq2xx:div", &(((acq2xx__InternalClockSetTransaction*)a)->div), "xsd:int"))
03005                                 {       soap_flag_div1--;
03006                                         continue;
03007                                 }
03008                         if (soap_flag_dox1 && soap->error == SOAP_TAG_MISMATCH)
03009                                 if (soap_in_acq2xx__DOx(soap, "acq2xx:dox", &(((acq2xx__InternalClockSetTransaction*)a)->dox), "acq2xx:DOx"))
03010                                 {       soap_flag_dox1--;
03011                                         continue;
03012                                 }
03013                         /* transient run skipped */
03014                         /* transient acq2xx__InternalClockSetTransaction skipped */
03015                         if (soap->error == SOAP_TAG_MISMATCH)
03016                                 soap->error = soap_ignore_element(soap);
03017                         if (soap->error == SOAP_NO_TAG)
03018                                 break;
03019                         if (soap->error)
03020                                 return NULL;
03021                 }
03022                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error4 > 0 || soap_flag_status4 > 0 || soap_flag_complete4 > 0 || soap_flag_hz1 > 0 || soap_flag_div1 > 0 || soap_flag_dox1 > 0))
03023                 {       soap->error = SOAP_OCCURS;
03024                         return NULL;
03025                 }
03026                 if (soap_element_end_in(soap, tag))
03027                         return NULL;
03028         }
03029         else
03030         {       a = (acq2xx__InternalClockSetTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__InternalClockSetTransaction, 0, sizeof(acq2xx__InternalClockSetTransaction), 0, soap_copy_acq2xx__InternalClockSetTransaction);
03031                 if (soap->body && soap_element_end_in(soap, tag))
03032                         return NULL;
03033         }
03034         return a;
03035 }
03036 
03037 SOAP_FMAC5 acq2xx__InternalClockSetTransaction * SOAP_FMAC6 soap_new_acq2xx__InternalClockSetTransaction(struct soap *soap, int n)
03038 {       return soap_instantiate_acq2xx__InternalClockSetTransaction(soap, n, NULL, NULL, NULL);
03039 }
03040 
03041 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__InternalClockSetTransaction(struct soap *soap, acq2xx__InternalClockSetTransaction *p)
03042 {       soap_delete(soap, p);
03043 }
03044 
03045 SOAP_FMAC3 acq2xx__InternalClockSetTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__InternalClockSetTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
03046 {
03047         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__InternalClockSetTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
03048         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__InternalClockSetTransaction, n, soap_fdelete);
03049         if (!cp)
03050                 return NULL;
03051         if (n < 0)
03052         {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction;
03053                 if (size)
03054                         *size = sizeof(acq2xx__InternalClockSetTransaction);
03055         }
03056         else
03057         {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction[n];
03058                 if (size)
03059                         *size = n * sizeof(acq2xx__InternalClockSetTransaction);
03060         }
03061                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03062         return (acq2xx__InternalClockSetTransaction*)cp->ptr;
03063 }
03064 
03065 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__InternalClockSetTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
03066 {
03067         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__InternalClockSetTransaction %p -> %p\n", q, p));
03068         *(acq2xx__InternalClockSetTransaction*)p = *(acq2xx__InternalClockSetTransaction*)q;
03069 }
03070 
03071 void acq2xx__ClockSetTransaction::soap_serialize(struct soap *soap) const
03072 {
03073         (void)soap; /* appease -Wall -Werror */
03074         /* transient acq2xx__ClockSetTransaction skipped */
03075         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->command);
03076         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->result);
03077         /* transient acq2xx__ShellTransaction skipped */
03078         /* transient acq2xx__ShellTransaction skipped */
03079         /* transient ~acq2xx__ShellTransaction skipped */
03080         /* transient getCommand skipped */
03081         /* transient getResult skipped */
03082         /* transient print skipped */
03083         /* transient initCommand skipped */
03084         /* transient run skipped */
03085         /* transient acq2xx__Transaction skipped */
03086         /* transient acq2xx__Transaction skipped */
03087         /* transient ~acq2xx__Transaction skipped */
03088         /* transient print skipped */
03089         /* transient exec skipped */
03090         /* transient getCommand skipped */
03091         /* transient getResult skipped */
03092         /* transient run skipped */
03093         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
03094         /* transient acq2xx__Object skipped */
03095         /* transient acq2xx__Object skipped */
03096         /* transient ~acq2xx__Object skipped */
03097         /* transient print skipped */
03098         /* transient getName skipped */
03099 }
03100 
03101 void acq2xx__ClockSetTransaction::soap_default(struct soap *soap)
03102 {
03103         (void)soap; /* appease -Wall -Werror */
03104         /* transient acq2xx__ClockSetTransaction skipped */
03105         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->command);
03106         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->result);
03107         /* transient acq2xx__ShellTransaction skipped */
03108         /* transient acq2xx__ShellTransaction skipped */
03109         /* transient ~acq2xx__ShellTransaction skipped */
03110         /* transient getCommand skipped */
03111         /* transient getResult skipped */
03112         /* transient print skipped */
03113         /* transient initCommand skipped */
03114         /* transient run skipped */
03115         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
03116         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
03117         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
03118         /* transient acq2xx__Transaction skipped */
03119         /* transient acq2xx__Transaction skipped */
03120         /* transient ~acq2xx__Transaction skipped */
03121         /* transient print skipped */
03122         /* transient exec skipped */
03123         /* transient getCommand skipped */
03124         /* transient getResult skipped */
03125         /* transient run skipped */
03126         soap_default_string(soap, &((acq2xx__Object*)this)->name);
03127         /* transient acq2xx__Object skipped */
03128         /* transient acq2xx__Object skipped */
03129         /* transient ~acq2xx__Object skipped */
03130         /* transient print skipped */
03131         /* transient getName skipped */
03132 }
03133 
03134 int acq2xx__ClockSetTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
03135 {
03136         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__ClockSetTransaction);
03137         if (this->soap_out(soap, tag, id, type))
03138                 return soap->error;
03139         return soap_putindependent(soap);
03140 }
03141 
03142 int acq2xx__ClockSetTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
03143 {
03144         return soap_out_acq2xx__ClockSetTransaction(soap, tag, id, this, type);
03145 }
03146 
03147 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__ClockSetTransaction(struct soap *soap, const char *tag, int id, const acq2xx__ClockSetTransaction *a, const char *type)
03148 {
03149         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__ClockSetTransaction), "acq2xx:ClockSetTransaction");
03150         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
03151         /* transient acq2xx__Object skipped */
03152         /* transient acq2xx__Object skipped */
03153         /* transient ~acq2xx__Object skipped */
03154         /* transient print skipped */
03155         /* transient getName skipped */
03156         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
03157         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
03158         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
03159         /* transient acq2xx__Transaction skipped */
03160         /* transient acq2xx__Transaction skipped */
03161         /* transient ~acq2xx__Transaction skipped */
03162         /* transient print skipped */
03163         /* transient exec skipped */
03164         /* transient getCommand skipped */
03165         /* transient getResult skipped */
03166         /* transient run skipped */
03167         soap_out_string(soap, "acq2xx:command", -1, &(((acq2xx__ShellTransaction*)a)->command), "xsd:string");
03168         soap_out_string(soap, "acq2xx:result", -1, &(((acq2xx__ShellTransaction*)a)->result), "xsd:string");
03169         /* transient acq2xx__ShellTransaction skipped */
03170         /* transient acq2xx__ShellTransaction skipped */
03171         /* transient ~acq2xx__ShellTransaction skipped */
03172         /* transient getCommand skipped */
03173         /* transient getResult skipped */
03174         /* transient print skipped */
03175         /* transient initCommand skipped */
03176         /* transient run skipped */
03177         /* transient acq2xx__ClockSetTransaction skipped */
03178         soap_element_end_out(soap, tag);
03179         return SOAP_OK;
03180 }
03181 
03182 void *acq2xx__ClockSetTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
03183 {
03184         return soap_get_acq2xx__ClockSetTransaction(soap, this, tag, type);
03185 }
03186 
03187 SOAP_FMAC3 acq2xx__ClockSetTransaction * SOAP_FMAC4 soap_get_acq2xx__ClockSetTransaction(struct soap *soap, acq2xx__ClockSetTransaction *p, const char *tag, const char *type)
03188 {
03189         if ((p = soap_in_acq2xx__ClockSetTransaction(soap, tag, p, type)))
03190                 soap_getindependent(soap);
03191         return p;
03192 }
03193 
03194 void *acq2xx__ClockSetTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
03195 {       return soap_in_acq2xx__ClockSetTransaction(soap, tag, this, type);
03196 }
03197 
03198 SOAP_FMAC3 acq2xx__ClockSetTransaction * SOAP_FMAC4 soap_in_acq2xx__ClockSetTransaction(struct soap *soap, const char *tag, acq2xx__ClockSetTransaction *a, const char *type)
03199 {
03200         if (soap_element_begin_in(soap, tag, 0, NULL))
03201                 return NULL;
03202         a = (acq2xx__ClockSetTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__ClockSetTransaction, sizeof(acq2xx__ClockSetTransaction), soap->type, soap->arrayType);
03203         if (!a)
03204                 return NULL;
03205         if (soap->alloced)
03206         {       a->soap_default(soap);
03207                 if (soap->clist->type != SOAP_TYPE_acq2xx__ClockSetTransaction)
03208                 {       soap_revert(soap);
03209                         *soap->id = '\0';
03210                         return (acq2xx__ClockSetTransaction *)a->soap_in(soap, tag, type);
03211                 }
03212         }
03213         short soap_flag_name4 = 1, soap_flag_abort_on_error3 = 1, soap_flag_status3 = 1, soap_flag_complete3 = 1, soap_flag_command2 = 1, soap_flag_result2 = 1;
03214         if (soap->body && !*soap->href)
03215         {
03216                 for (;;)
03217                 {       soap->error = SOAP_TAG_MISMATCH;
03218                         if (soap_flag_name4 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03219                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
03220                                 {       soap_flag_name4--;
03221                                         continue;
03222                                 }
03223                         /* transient acq2xx__Object skipped */
03224                         /* transient acq2xx__Object skipped */
03225                         /* transient ~acq2xx__Object skipped */
03226                         /* transient print skipped */
03227                         /* transient getName skipped */
03228                         if (soap_flag_abort_on_error3 && soap->error == SOAP_TAG_MISMATCH)
03229                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
03230                                 {       soap_flag_abort_on_error3--;
03231                                         continue;
03232                                 }
03233                         if (soap_flag_status3 && soap->error == SOAP_TAG_MISMATCH)
03234                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
03235                                 {       soap_flag_status3--;
03236                                         continue;
03237                                 }
03238                         if (soap_flag_complete3 && soap->error == SOAP_TAG_MISMATCH)
03239                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
03240                                 {       soap_flag_complete3--;
03241                                         continue;
03242                                 }
03243                         /* transient acq2xx__Transaction skipped */
03244                         /* transient acq2xx__Transaction skipped */
03245                         /* transient ~acq2xx__Transaction skipped */
03246                         /* transient print skipped */
03247                         /* transient exec skipped */
03248                         /* transient getCommand skipped */
03249                         /* transient getResult skipped */
03250                         /* transient run skipped */
03251                         if (soap_flag_command2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03252                                 if (soap_in_string(soap, "acq2xx:command", &(((acq2xx__ShellTransaction*)a)->command), "xsd:string"))
03253                                 {       soap_flag_command2--;
03254                                         continue;
03255                                 }
03256                         if (soap_flag_result2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03257                                 if (soap_in_string(soap, "acq2xx:result", &(((acq2xx__ShellTransaction*)a)->result), "xsd:string"))
03258                                 {       soap_flag_result2--;
03259                                         continue;
03260                                 }
03261                         /* transient acq2xx__ShellTransaction skipped */
03262                         /* transient acq2xx__ShellTransaction skipped */
03263                         /* transient ~acq2xx__ShellTransaction skipped */
03264                         /* transient getCommand skipped */
03265                         /* transient getResult skipped */
03266                         /* transient print skipped */
03267                         /* transient initCommand skipped */
03268                         /* transient run skipped */
03269                         /* transient acq2xx__ClockSetTransaction skipped */
03270                         if (soap->error == SOAP_TAG_MISMATCH)
03271                                 soap->error = soap_ignore_element(soap);
03272                         if (soap->error == SOAP_NO_TAG)
03273                                 break;
03274                         if (soap->error)
03275                                 return NULL;
03276                 }
03277                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error3 > 0 || soap_flag_status3 > 0 || soap_flag_complete3 > 0))
03278                 {       soap->error = SOAP_OCCURS;
03279                         return NULL;
03280                 }
03281                 if (soap_element_end_in(soap, tag))
03282                         return NULL;
03283         }
03284         else
03285         {       a = (acq2xx__ClockSetTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__ClockSetTransaction, 0, sizeof(acq2xx__ClockSetTransaction), 0, soap_copy_acq2xx__ClockSetTransaction);
03286                 if (soap->body && soap_element_end_in(soap, tag))
03287                         return NULL;
03288         }
03289         return a;
03290 }
03291 
03292 SOAP_FMAC5 acq2xx__ClockSetTransaction * SOAP_FMAC6 soap_new_acq2xx__ClockSetTransaction(struct soap *soap, int n)
03293 {       return soap_instantiate_acq2xx__ClockSetTransaction(soap, n, NULL, NULL, NULL);
03294 }
03295 
03296 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__ClockSetTransaction(struct soap *soap, acq2xx__ClockSetTransaction *p)
03297 {       soap_delete(soap, p);
03298 }
03299 
03300 SOAP_FMAC3 acq2xx__ClockSetTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__ClockSetTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
03301 {
03302         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__ClockSetTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
03303         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__ClockSetTransaction, n, soap_fdelete);
03304         if (!cp)
03305                 return NULL;
03306         if (type && !soap_match_tag(soap, type, "acq2xx:InternalClockSetTransaction"))
03307         {       cp->type = SOAP_TYPE_acq2xx__InternalClockSetTransaction;
03308                 if (n < 0)
03309                 {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction;
03310                         if (size)
03311                                 *size = sizeof(acq2xx__InternalClockSetTransaction);
03312                 }
03313                 else
03314                 {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction[n];
03315                         if (size)
03316                                 *size = n * sizeof(acq2xx__InternalClockSetTransaction);
03317                 }
03318         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03319                 return (acq2xx__InternalClockSetTransaction*)cp->ptr;
03320         }
03321         if (type && !soap_match_tag(soap, type, "acq2xx:ExternalClockSetTransaction"))
03322         {       cp->type = SOAP_TYPE_acq2xx__ExternalClockSetTransaction;
03323                 if (n < 0)
03324                 {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction;
03325                         if (size)
03326                                 *size = sizeof(acq2xx__ExternalClockSetTransaction);
03327                 }
03328                 else
03329                 {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction[n];
03330                         if (size)
03331                                 *size = n * sizeof(acq2xx__ExternalClockSetTransaction);
03332                 }
03333         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03334                 return (acq2xx__ExternalClockSetTransaction*)cp->ptr;
03335         }
03336         if (n < 0)
03337         {       cp->ptr = (void*)new acq2xx__ClockSetTransaction;
03338                 if (size)
03339                         *size = sizeof(acq2xx__ClockSetTransaction);
03340         }
03341         else
03342         {       cp->ptr = (void*)new acq2xx__ClockSetTransaction[n];
03343                 if (size)
03344                         *size = n * sizeof(acq2xx__ClockSetTransaction);
03345         }
03346                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03347         return (acq2xx__ClockSetTransaction*)cp->ptr;
03348 }
03349 
03350 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__ClockSetTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
03351 {
03352         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__ClockSetTransaction %p -> %p\n", q, p));
03353         *(acq2xx__ClockSetTransaction*)p = *(acq2xx__ClockSetTransaction*)q;
03354 }
03355 
03356 void acq2xx__ModeSetTransaction::soap_serialize(struct soap *soap) const
03357 {
03358         (void)soap; /* appease -Wall -Werror */
03359         /* transient run skipped */
03360         /* transient acq2xx__ModeSetTransaction skipped */
03361         /* transient acq2xx__ModeSetTransaction skipped */
03362         /* transient print skipped */
03363         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->command);
03364         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->result);
03365         /* transient acq2xx__ShellTransaction skipped */
03366         /* transient acq2xx__ShellTransaction skipped */
03367         /* transient ~acq2xx__ShellTransaction skipped */
03368         /* transient getCommand skipped */
03369         /* transient getResult skipped */
03370         /* transient print skipped */
03371         /* transient initCommand skipped */
03372         /* transient run skipped */
03373         /* transient acq2xx__Transaction skipped */
03374         /* transient acq2xx__Transaction skipped */
03375         /* transient ~acq2xx__Transaction skipped */
03376         /* transient print skipped */
03377         /* transient exec skipped */
03378         /* transient getCommand skipped */
03379         /* transient getResult skipped */
03380         /* transient run skipped */
03381         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
03382         /* transient acq2xx__Object skipped */
03383         /* transient acq2xx__Object skipped */
03384         /* transient ~acq2xx__Object skipped */
03385         /* transient print skipped */
03386         /* transient getName skipped */
03387 }
03388 
03389 void acq2xx__ModeSetTransaction::soap_default(struct soap *soap)
03390 {
03391         (void)soap; /* appease -Wall -Werror */
03392         soap_default_acq2xx__MODE(soap, &((acq2xx__ModeSetTransaction*)this)->mode);
03393         soap_default_int(soap, &((acq2xx__ModeSetTransaction*)this)->prelen);
03394         soap_default_int(soap, &((acq2xx__ModeSetTransaction*)this)->postlen);
03395         /* transient run skipped */
03396         /* transient acq2xx__ModeSetTransaction skipped */
03397         /* transient acq2xx__ModeSetTransaction skipped */
03398         /* transient print skipped */
03399         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->command);
03400         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->result);
03401         /* transient acq2xx__ShellTransaction skipped */
03402         /* transient acq2xx__ShellTransaction skipped */
03403         /* transient ~acq2xx__ShellTransaction skipped */
03404         /* transient getCommand skipped */
03405         /* transient getResult skipped */
03406         /* transient print skipped */
03407         /* transient initCommand skipped */
03408         /* transient run skipped */
03409         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
03410         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
03411         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
03412         /* transient acq2xx__Transaction skipped */
03413         /* transient acq2xx__Transaction skipped */
03414         /* transient ~acq2xx__Transaction skipped */
03415         /* transient print skipped */
03416         /* transient exec skipped */
03417         /* transient getCommand skipped */
03418         /* transient getResult skipped */
03419         /* transient run skipped */
03420         soap_default_string(soap, &((acq2xx__Object*)this)->name);
03421         /* transient acq2xx__Object skipped */
03422         /* transient acq2xx__Object skipped */
03423         /* transient ~acq2xx__Object skipped */
03424         /* transient print skipped */
03425         /* transient getName skipped */
03426 }
03427 
03428 int acq2xx__ModeSetTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
03429 {
03430         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__ModeSetTransaction);
03431         if (this->soap_out(soap, tag, id, type))
03432                 return soap->error;
03433         return soap_putindependent(soap);
03434 }
03435 
03436 int acq2xx__ModeSetTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
03437 {
03438         return soap_out_acq2xx__ModeSetTransaction(soap, tag, id, this, type);
03439 }
03440 
03441 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__ModeSetTransaction(struct soap *soap, const char *tag, int id, const acq2xx__ModeSetTransaction *a, const char *type)
03442 {
03443         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__ModeSetTransaction), "acq2xx:ModeSetTransaction");
03444         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
03445         /* transient acq2xx__Object skipped */
03446         /* transient acq2xx__Object skipped */
03447         /* transient ~acq2xx__Object skipped */
03448         /* transient print skipped */
03449         /* transient getName skipped */
03450         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
03451         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
03452         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
03453         /* transient acq2xx__Transaction skipped */
03454         /* transient acq2xx__Transaction skipped */
03455         /* transient ~acq2xx__Transaction skipped */
03456         /* transient print skipped */
03457         /* transient exec skipped */
03458         /* transient getCommand skipped */
03459         /* transient getResult skipped */
03460         /* transient run skipped */
03461         soap_out_string(soap, "acq2xx:command", -1, &(((acq2xx__ShellTransaction*)a)->command), "xsd:string");
03462         soap_out_string(soap, "acq2xx:result", -1, &(((acq2xx__ShellTransaction*)a)->result), "xsd:string");
03463         /* transient acq2xx__ShellTransaction skipped */
03464         /* transient acq2xx__ShellTransaction skipped */
03465         /* transient ~acq2xx__ShellTransaction skipped */
03466         /* transient getCommand skipped */
03467         /* transient getResult skipped */
03468         /* transient print skipped */
03469         /* transient initCommand skipped */
03470         /* transient run skipped */
03471         soap_out_acq2xx__MODE(soap, "acq2xx:mode", -1, &(((acq2xx__ModeSetTransaction*)a)->mode), "acq2xx:MODE");
03472         soap_out_int(soap, "acq2xx:prelen", -1, &(((acq2xx__ModeSetTransaction*)a)->prelen), "xsd:int");
03473         soap_out_int(soap, "acq2xx:postlen", -1, &(((acq2xx__ModeSetTransaction*)a)->postlen), "xsd:int");
03474         /* transient run skipped */
03475         /* transient acq2xx__ModeSetTransaction skipped */
03476         /* transient acq2xx__ModeSetTransaction skipped */
03477         /* transient print skipped */
03478         soap_element_end_out(soap, tag);
03479         return SOAP_OK;
03480 }
03481 
03482 void *acq2xx__ModeSetTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
03483 {
03484         return soap_get_acq2xx__ModeSetTransaction(soap, this, tag, type);
03485 }
03486 
03487 SOAP_FMAC3 acq2xx__ModeSetTransaction * SOAP_FMAC4 soap_get_acq2xx__ModeSetTransaction(struct soap *soap, acq2xx__ModeSetTransaction *p, const char *tag, const char *type)
03488 {
03489         if ((p = soap_in_acq2xx__ModeSetTransaction(soap, tag, p, type)))
03490                 soap_getindependent(soap);
03491         return p;
03492 }
03493 
03494 void *acq2xx__ModeSetTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
03495 {       return soap_in_acq2xx__ModeSetTransaction(soap, tag, this, type);
03496 }
03497 
03498 SOAP_FMAC3 acq2xx__ModeSetTransaction * SOAP_FMAC4 soap_in_acq2xx__ModeSetTransaction(struct soap *soap, const char *tag, acq2xx__ModeSetTransaction *a, const char *type)
03499 {
03500         if (soap_element_begin_in(soap, tag, 0, NULL))
03501                 return NULL;
03502         a = (acq2xx__ModeSetTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__ModeSetTransaction, sizeof(acq2xx__ModeSetTransaction), soap->type, soap->arrayType);
03503         if (!a)
03504                 return NULL;
03505         if (soap->alloced)
03506         {       a->soap_default(soap);
03507                 if (soap->clist->type != SOAP_TYPE_acq2xx__ModeSetTransaction)
03508                 {       soap_revert(soap);
03509                         *soap->id = '\0';
03510                         return (acq2xx__ModeSetTransaction *)a->soap_in(soap, tag, type);
03511                 }
03512         }
03513         short soap_flag_name4 = 1, soap_flag_abort_on_error3 = 1, soap_flag_status3 = 1, soap_flag_complete3 = 1, soap_flag_command2 = 1, soap_flag_result2 = 1, soap_flag_mode1 = 1, soap_flag_prelen1 = 1, soap_flag_postlen1 = 1;
03514         if (soap->body && !*soap->href)
03515         {
03516                 for (;;)
03517                 {       soap->error = SOAP_TAG_MISMATCH;
03518                         if (soap_flag_name4 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03519                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
03520                                 {       soap_flag_name4--;
03521                                         continue;
03522                                 }
03523                         /* transient acq2xx__Object skipped */
03524                         /* transient acq2xx__Object skipped */
03525                         /* transient ~acq2xx__Object skipped */
03526                         /* transient print skipped */
03527                         /* transient getName skipped */
03528                         if (soap_flag_abort_on_error3 && soap->error == SOAP_TAG_MISMATCH)
03529                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
03530                                 {       soap_flag_abort_on_error3--;
03531                                         continue;
03532                                 }
03533                         if (soap_flag_status3 && soap->error == SOAP_TAG_MISMATCH)
03534                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
03535                                 {       soap_flag_status3--;
03536                                         continue;
03537                                 }
03538                         if (soap_flag_complete3 && soap->error == SOAP_TAG_MISMATCH)
03539                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
03540                                 {       soap_flag_complete3--;
03541                                         continue;
03542                                 }
03543                         /* transient acq2xx__Transaction skipped */
03544                         /* transient acq2xx__Transaction skipped */
03545                         /* transient ~acq2xx__Transaction skipped */
03546                         /* transient print skipped */
03547                         /* transient exec skipped */
03548                         /* transient getCommand skipped */
03549                         /* transient getResult skipped */
03550                         /* transient run skipped */
03551                         if (soap_flag_command2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03552                                 if (soap_in_string(soap, "acq2xx:command", &(((acq2xx__ShellTransaction*)a)->command), "xsd:string"))
03553                                 {       soap_flag_command2--;
03554                                         continue;
03555                                 }
03556                         if (soap_flag_result2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03557                                 if (soap_in_string(soap, "acq2xx:result", &(((acq2xx__ShellTransaction*)a)->result), "xsd:string"))
03558                                 {       soap_flag_result2--;
03559                                         continue;
03560                                 }
03561                         /* transient acq2xx__ShellTransaction skipped */
03562                         /* transient acq2xx__ShellTransaction skipped */
03563                         /* transient ~acq2xx__ShellTransaction skipped */
03564                         /* transient getCommand skipped */
03565                         /* transient getResult skipped */
03566                         /* transient print skipped */
03567                         /* transient initCommand skipped */
03568                         /* transient run skipped */
03569                         if (soap_flag_mode1 && soap->error == SOAP_TAG_MISMATCH)
03570                                 if (soap_in_acq2xx__MODE(soap, "acq2xx:mode", &(((acq2xx__ModeSetTransaction*)a)->mode), "acq2xx:MODE"))
03571                                 {       soap_flag_mode1--;
03572                                         continue;
03573                                 }
03574                         if (soap_flag_prelen1 && soap->error == SOAP_TAG_MISMATCH)
03575                                 if (soap_in_int(soap, "acq2xx:prelen", &(((acq2xx__ModeSetTransaction*)a)->prelen), "xsd:int"))
03576                                 {       soap_flag_prelen1--;
03577                                         continue;
03578                                 }
03579                         if (soap_flag_postlen1 && soap->error == SOAP_TAG_MISMATCH)
03580                                 if (soap_in_int(soap, "acq2xx:postlen", &(((acq2xx__ModeSetTransaction*)a)->postlen), "xsd:int"))
03581                                 {       soap_flag_postlen1--;
03582                                         continue;
03583                                 }
03584                         /* transient run skipped */
03585                         /* transient acq2xx__ModeSetTransaction skipped */
03586                         /* transient acq2xx__ModeSetTransaction skipped */
03587                         /* transient print skipped */
03588                         if (soap->error == SOAP_TAG_MISMATCH)
03589                                 soap->error = soap_ignore_element(soap);
03590                         if (soap->error == SOAP_NO_TAG)
03591                                 break;
03592                         if (soap->error)
03593                                 return NULL;
03594                 }
03595                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error3 > 0 || soap_flag_status3 > 0 || soap_flag_complete3 > 0 || soap_flag_mode1 > 0 || soap_flag_prelen1 > 0 || soap_flag_postlen1 > 0))
03596                 {       soap->error = SOAP_OCCURS;
03597                         return NULL;
03598                 }
03599                 if (soap_element_end_in(soap, tag))
03600                         return NULL;
03601         }
03602         else
03603         {       a = (acq2xx__ModeSetTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__ModeSetTransaction, 0, sizeof(acq2xx__ModeSetTransaction), 0, soap_copy_acq2xx__ModeSetTransaction);
03604                 if (soap->body && soap_element_end_in(soap, tag))
03605                         return NULL;
03606         }
03607         return a;
03608 }
03609 
03610 SOAP_FMAC5 acq2xx__ModeSetTransaction * SOAP_FMAC6 soap_new_acq2xx__ModeSetTransaction(struct soap *soap, int n)
03611 {       return soap_instantiate_acq2xx__ModeSetTransaction(soap, n, NULL, NULL, NULL);
03612 }
03613 
03614 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__ModeSetTransaction(struct soap *soap, acq2xx__ModeSetTransaction *p)
03615 {       soap_delete(soap, p);
03616 }
03617 
03618 SOAP_FMAC3 acq2xx__ModeSetTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__ModeSetTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
03619 {
03620         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__ModeSetTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
03621         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__ModeSetTransaction, n, soap_fdelete);
03622         if (!cp)
03623                 return NULL;
03624         if (n < 0)
03625         {       cp->ptr = (void*)new acq2xx__ModeSetTransaction;
03626                 if (size)
03627                         *size = sizeof(acq2xx__ModeSetTransaction);
03628         }
03629         else
03630         {       cp->ptr = (void*)new acq2xx__ModeSetTransaction[n];
03631                 if (size)
03632                         *size = n * sizeof(acq2xx__ModeSetTransaction);
03633         }
03634                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03635         return (acq2xx__ModeSetTransaction*)cp->ptr;
03636 }
03637 
03638 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__ModeSetTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
03639 {
03640         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__ModeSetTransaction %p -> %p\n", q, p));
03641         *(acq2xx__ModeSetTransaction*)p = *(acq2xx__ModeSetTransaction*)q;
03642 }
03643 
03644 void acq2xx__ShellTransaction::soap_serialize(struct soap *soap) const
03645 {
03646         (void)soap; /* appease -Wall -Werror */
03647         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->command);
03648         soap_serialize_string(soap, &((acq2xx__ShellTransaction*)this)->result);
03649         /* transient acq2xx__ShellTransaction skipped */
03650         /* transient acq2xx__ShellTransaction skipped */
03651         /* transient ~acq2xx__ShellTransaction skipped */
03652         /* transient getCommand skipped */
03653         /* transient getResult skipped */
03654         /* transient print skipped */
03655         /* transient initCommand skipped */
03656         /* transient run skipped */
03657         /* transient acq2xx__Transaction skipped */
03658         /* transient acq2xx__Transaction skipped */
03659         /* transient ~acq2xx__Transaction skipped */
03660         /* transient print skipped */
03661         /* transient exec skipped */
03662         /* transient getCommand skipped */
03663         /* transient getResult skipped */
03664         /* transient run skipped */
03665         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
03666         /* transient acq2xx__Object skipped */
03667         /* transient acq2xx__Object skipped */
03668         /* transient ~acq2xx__Object skipped */
03669         /* transient print skipped */
03670         /* transient getName skipped */
03671 }
03672 
03673 void acq2xx__ShellTransaction::soap_default(struct soap *soap)
03674 {
03675         (void)soap; /* appease -Wall -Werror */
03676         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->command);
03677         soap_default_string(soap, &((acq2xx__ShellTransaction*)this)->result);
03678         /* transient acq2xx__ShellTransaction skipped */
03679         /* transient acq2xx__ShellTransaction skipped */
03680         /* transient ~acq2xx__ShellTransaction skipped */
03681         /* transient getCommand skipped */
03682         /* transient getResult skipped */
03683         /* transient print skipped */
03684         /* transient initCommand skipped */
03685         /* transient run skipped */
03686         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
03687         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
03688         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
03689         /* transient acq2xx__Transaction skipped */
03690         /* transient acq2xx__Transaction skipped */
03691         /* transient ~acq2xx__Transaction skipped */
03692         /* transient print skipped */
03693         /* transient exec skipped */
03694         /* transient getCommand skipped */
03695         /* transient getResult skipped */
03696         /* transient run skipped */
03697         soap_default_string(soap, &((acq2xx__Object*)this)->name);
03698         /* transient acq2xx__Object skipped */
03699         /* transient acq2xx__Object skipped */
03700         /* transient ~acq2xx__Object skipped */
03701         /* transient print skipped */
03702         /* transient getName skipped */
03703 }
03704 
03705 int acq2xx__ShellTransaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
03706 {
03707         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__ShellTransaction);
03708         if (this->soap_out(soap, tag, id, type))
03709                 return soap->error;
03710         return soap_putindependent(soap);
03711 }
03712 
03713 int acq2xx__ShellTransaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
03714 {
03715         return soap_out_acq2xx__ShellTransaction(soap, tag, id, this, type);
03716 }
03717 
03718 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__ShellTransaction(struct soap *soap, const char *tag, int id, const acq2xx__ShellTransaction *a, const char *type)
03719 {
03720         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__ShellTransaction), "acq2xx:ShellTransaction");
03721         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
03722         /* transient acq2xx__Object skipped */
03723         /* transient acq2xx__Object skipped */
03724         /* transient ~acq2xx__Object skipped */
03725         /* transient print skipped */
03726         /* transient getName skipped */
03727         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
03728         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
03729         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
03730         /* transient acq2xx__Transaction skipped */
03731         /* transient acq2xx__Transaction skipped */
03732         /* transient ~acq2xx__Transaction skipped */
03733         /* transient print skipped */
03734         /* transient exec skipped */
03735         /* transient getCommand skipped */
03736         /* transient getResult skipped */
03737         /* transient run skipped */
03738         soap_out_string(soap, "acq2xx:command", -1, &(((acq2xx__ShellTransaction*)a)->command), "xsd:string");
03739         soap_out_string(soap, "acq2xx:result", -1, &(((acq2xx__ShellTransaction*)a)->result), "xsd:string");
03740         /* transient acq2xx__ShellTransaction skipped */
03741         /* transient acq2xx__ShellTransaction skipped */
03742         /* transient ~acq2xx__ShellTransaction skipped */
03743         /* transient getCommand skipped */
03744         /* transient getResult skipped */
03745         /* transient print skipped */
03746         /* transient initCommand skipped */
03747         /* transient run skipped */
03748         soap_element_end_out(soap, tag);
03749         return SOAP_OK;
03750 }
03751 
03752 void *acq2xx__ShellTransaction::soap_get(struct soap *soap, const char *tag, const char *type)
03753 {
03754         return soap_get_acq2xx__ShellTransaction(soap, this, tag, type);
03755 }
03756 
03757 SOAP_FMAC3 acq2xx__ShellTransaction * SOAP_FMAC4 soap_get_acq2xx__ShellTransaction(struct soap *soap, acq2xx__ShellTransaction *p, const char *tag, const char *type)
03758 {
03759         if ((p = soap_in_acq2xx__ShellTransaction(soap, tag, p, type)))
03760                 soap_getindependent(soap);
03761         return p;
03762 }
03763 
03764 void *acq2xx__ShellTransaction::soap_in(struct soap *soap, const char *tag, const char *type)
03765 {       return soap_in_acq2xx__ShellTransaction(soap, tag, this, type);
03766 }
03767 
03768 SOAP_FMAC3 acq2xx__ShellTransaction * SOAP_FMAC4 soap_in_acq2xx__ShellTransaction(struct soap *soap, const char *tag, acq2xx__ShellTransaction *a, const char *type)
03769 {
03770         if (soap_element_begin_in(soap, tag, 0, NULL))
03771                 return NULL;
03772         a = (acq2xx__ShellTransaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__ShellTransaction, sizeof(acq2xx__ShellTransaction), soap->type, soap->arrayType);
03773         if (!a)
03774                 return NULL;
03775         if (soap->alloced)
03776         {       a->soap_default(soap);
03777                 if (soap->clist->type != SOAP_TYPE_acq2xx__ShellTransaction)
03778                 {       soap_revert(soap);
03779                         *soap->id = '\0';
03780                         return (acq2xx__ShellTransaction *)a->soap_in(soap, tag, type);
03781                 }
03782         }
03783         short soap_flag_name3 = 1, soap_flag_abort_on_error2 = 1, soap_flag_status2 = 1, soap_flag_complete2 = 1, soap_flag_command1 = 1, soap_flag_result1 = 1;
03784         if (soap->body && !*soap->href)
03785         {
03786                 for (;;)
03787                 {       soap->error = SOAP_TAG_MISMATCH;
03788                         if (soap_flag_name3 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03789                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
03790                                 {       soap_flag_name3--;
03791                                         continue;
03792                                 }
03793                         /* transient acq2xx__Object skipped */
03794                         /* transient acq2xx__Object skipped */
03795                         /* transient ~acq2xx__Object skipped */
03796                         /* transient print skipped */
03797                         /* transient getName skipped */
03798                         if (soap_flag_abort_on_error2 && soap->error == SOAP_TAG_MISMATCH)
03799                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
03800                                 {       soap_flag_abort_on_error2--;
03801                                         continue;
03802                                 }
03803                         if (soap_flag_status2 && soap->error == SOAP_TAG_MISMATCH)
03804                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
03805                                 {       soap_flag_status2--;
03806                                         continue;
03807                                 }
03808                         if (soap_flag_complete2 && soap->error == SOAP_TAG_MISMATCH)
03809                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
03810                                 {       soap_flag_complete2--;
03811                                         continue;
03812                                 }
03813                         /* transient acq2xx__Transaction skipped */
03814                         /* transient acq2xx__Transaction skipped */
03815                         /* transient ~acq2xx__Transaction skipped */
03816                         /* transient print skipped */
03817                         /* transient exec skipped */
03818                         /* transient getCommand skipped */
03819                         /* transient getResult skipped */
03820                         /* transient run skipped */
03821                         if (soap_flag_command1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03822                                 if (soap_in_string(soap, "acq2xx:command", &(((acq2xx__ShellTransaction*)a)->command), "xsd:string"))
03823                                 {       soap_flag_command1--;
03824                                         continue;
03825                                 }
03826                         if (soap_flag_result1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
03827                                 if (soap_in_string(soap, "acq2xx:result", &(((acq2xx__ShellTransaction*)a)->result), "xsd:string"))
03828                                 {       soap_flag_result1--;
03829                                         continue;
03830                                 }
03831                         /* transient acq2xx__ShellTransaction skipped */
03832                         /* transient acq2xx__ShellTransaction skipped */
03833                         /* transient ~acq2xx__ShellTransaction skipped */
03834                         /* transient getCommand skipped */
03835                         /* transient getResult skipped */
03836                         /* transient print skipped */
03837                         /* transient initCommand skipped */
03838                         /* transient run skipped */
03839                         if (soap->error == SOAP_TAG_MISMATCH)
03840                                 soap->error = soap_ignore_element(soap);
03841                         if (soap->error == SOAP_NO_TAG)
03842                                 break;
03843                         if (soap->error)
03844                                 return NULL;
03845                 }
03846                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error2 > 0 || soap_flag_status2 > 0 || soap_flag_complete2 > 0))
03847                 {       soap->error = SOAP_OCCURS;
03848                         return NULL;
03849                 }
03850                 if (soap_element_end_in(soap, tag))
03851                         return NULL;
03852         }
03853         else
03854         {       a = (acq2xx__ShellTransaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__ShellTransaction, 0, sizeof(acq2xx__ShellTransaction), 0, soap_copy_acq2xx__ShellTransaction);
03855                 if (soap->body && soap_element_end_in(soap, tag))
03856                         return NULL;
03857         }
03858         return a;
03859 }
03860 
03861 SOAP_FMAC5 acq2xx__ShellTransaction * SOAP_FMAC6 soap_new_acq2xx__ShellTransaction(struct soap *soap, int n)
03862 {       return soap_instantiate_acq2xx__ShellTransaction(soap, n, NULL, NULL, NULL);
03863 }
03864 
03865 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__ShellTransaction(struct soap *soap, acq2xx__ShellTransaction *p)
03866 {       soap_delete(soap, p);
03867 }
03868 
03869 SOAP_FMAC3 acq2xx__ShellTransaction * SOAP_FMAC4 soap_instantiate_acq2xx__ShellTransaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
03870 {
03871         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__ShellTransaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
03872         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__ShellTransaction, n, soap_fdelete);
03873         if (!cp)
03874                 return NULL;
03875         if (type && !soap_match_tag(soap, type, "acq2xx:ModeSetTransaction"))
03876         {       cp->type = SOAP_TYPE_acq2xx__ModeSetTransaction;
03877                 if (n < 0)
03878                 {       cp->ptr = (void*)new acq2xx__ModeSetTransaction;
03879                         if (size)
03880                                 *size = sizeof(acq2xx__ModeSetTransaction);
03881                 }
03882                 else
03883                 {       cp->ptr = (void*)new acq2xx__ModeSetTransaction[n];
03884                         if (size)
03885                                 *size = n * sizeof(acq2xx__ModeSetTransaction);
03886                 }
03887         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03888                 return (acq2xx__ModeSetTransaction*)cp->ptr;
03889         }
03890         if (type && !soap_match_tag(soap, type, "acq2xx:ClockSetTransaction"))
03891         {       cp->type = SOAP_TYPE_acq2xx__ClockSetTransaction;
03892                 if (n < 0)
03893                 {       cp->ptr = (void*)new acq2xx__ClockSetTransaction;
03894                         if (size)
03895                                 *size = sizeof(acq2xx__ClockSetTransaction);
03896                 }
03897                 else
03898                 {       cp->ptr = (void*)new acq2xx__ClockSetTransaction[n];
03899                         if (size)
03900                                 *size = n * sizeof(acq2xx__ClockSetTransaction);
03901                 }
03902         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03903                 return (acq2xx__ClockSetTransaction*)cp->ptr;
03904         }
03905         if (type && !soap_match_tag(soap, type, "acq2xx:InternalClockSetTransaction"))
03906         {       cp->type = SOAP_TYPE_acq2xx__InternalClockSetTransaction;
03907                 if (n < 0)
03908                 {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction;
03909                         if (size)
03910                                 *size = sizeof(acq2xx__InternalClockSetTransaction);
03911                 }
03912                 else
03913                 {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction[n];
03914                         if (size)
03915                                 *size = n * sizeof(acq2xx__InternalClockSetTransaction);
03916                 }
03917         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03918                 return (acq2xx__InternalClockSetTransaction*)cp->ptr;
03919         }
03920         if (type && !soap_match_tag(soap, type, "acq2xx:ExternalClockSetTransaction"))
03921         {       cp->type = SOAP_TYPE_acq2xx__ExternalClockSetTransaction;
03922                 if (n < 0)
03923                 {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction;
03924                         if (size)
03925                                 *size = sizeof(acq2xx__ExternalClockSetTransaction);
03926                 }
03927                 else
03928                 {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction[n];
03929                         if (size)
03930                                 *size = n * sizeof(acq2xx__ExternalClockSetTransaction);
03931                 }
03932         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03933                 return (acq2xx__ExternalClockSetTransaction*)cp->ptr;
03934         }
03935         if (type && !soap_match_tag(soap, type, "acq2xx:SignalSetTransaction"))
03936         {       cp->type = SOAP_TYPE_acq2xx__SignalSetTransaction;
03937                 if (n < 0)
03938                 {       cp->ptr = (void*)new acq2xx__SignalSetTransaction;
03939                         if (size)
03940                                 *size = sizeof(acq2xx__SignalSetTransaction);
03941                 }
03942                 else
03943                 {       cp->ptr = (void*)new acq2xx__SignalSetTransaction[n];
03944                         if (size)
03945                                 *size = n * sizeof(acq2xx__SignalSetTransaction);
03946                 }
03947         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03948                 return (acq2xx__SignalSetTransaction*)cp->ptr;
03949         }
03950         if (type && !soap_match_tag(soap, type, "acq2xx:GetAvailableChannelsTransaction"))
03951         {       cp->type = SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction;
03952                 if (n < 0)
03953                 {       cp->ptr = (void*)new acq2xx__GetAvailableChannelsTransaction;
03954                         if (size)
03955                                 *size = sizeof(acq2xx__GetAvailableChannelsTransaction);
03956                 }
03957                 else
03958                 {       cp->ptr = (void*)new acq2xx__GetAvailableChannelsTransaction[n];
03959                         if (size)
03960                                 *size = n * sizeof(acq2xx__GetAvailableChannelsTransaction);
03961                 }
03962         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03963                 return (acq2xx__GetAvailableChannelsTransaction*)cp->ptr;
03964         }
03965         if (type && !soap_match_tag(soap, type, "acq2xx:GetVRangeTransaction"))
03966         {       cp->type = SOAP_TYPE_acq2xx__GetVRangeTransaction;
03967                 if (n < 0)
03968                 {       cp->ptr = (void*)new acq2xx__GetVRangeTransaction;
03969                         if (size)
03970                                 *size = sizeof(acq2xx__GetVRangeTransaction);
03971                 }
03972                 else
03973                 {       cp->ptr = (void*)new acq2xx__GetVRangeTransaction[n];
03974                         if (size)
03975                                 *size = n * sizeof(acq2xx__GetVRangeTransaction);
03976                 }
03977         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03978                 return (acq2xx__GetVRangeTransaction*)cp->ptr;
03979         }
03980         if (n < 0)
03981         {       cp->ptr = (void*)new acq2xx__ShellTransaction;
03982                 if (size)
03983                         *size = sizeof(acq2xx__ShellTransaction);
03984         }
03985         else
03986         {       cp->ptr = (void*)new acq2xx__ShellTransaction[n];
03987                 if (size)
03988                         *size = n * sizeof(acq2xx__ShellTransaction);
03989         }
03990                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
03991         return (acq2xx__ShellTransaction*)cp->ptr;
03992 }
03993 
03994 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__ShellTransaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
03995 {
03996         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__ShellTransaction %p -> %p\n", q, p));
03997         *(acq2xx__ShellTransaction*)p = *(acq2xx__ShellTransaction*)q;
03998 }
03999 
04000 void acq2xx__TransactionList::soap_serialize(struct soap *soap) const
04001 {
04002         if (this->__ptr && !soap_array_reference(soap, this, (struct soap_array*)&this->__ptr, 1, SOAP_TYPE_acq2xx__TransactionList))
04003                 for (int i = 0; i < this->__size; i++)
04004                 {
04005                         soap_serialize_PointerToacq2xx__Transaction(soap, this->__ptr + i);
04006                 }
04007 }
04008 
04009 void acq2xx__TransactionList::soap_default(struct soap *soap)
04010 {
04011         this->__size = 0;
04012         this->__ptr = NULL;
04013 }
04014 
04015 int acq2xx__TransactionList::soap_put(struct soap *soap, const char *tag, const  char *type) const
04016 {
04017         register int id = soap_embed(soap, (void*)this, (struct soap_array*)&this->__ptr, 1, tag, SOAP_TYPE_acq2xx__TransactionList);
04018         if (this->soap_out(soap, tag, id, type))
04019                 return soap->error;
04020         return soap_putindependent(soap);
04021 }
04022 
04023 int acq2xx__TransactionList::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
04024 {       return soap_out_acq2xx__TransactionList(soap, tag, id, this, type);
04025 }
04026 
04027 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__TransactionList(struct soap *soap, const char *tag, int id, const acq2xx__TransactionList *a, const char *type)
04028 {
04029         int i, n = a->__size;
04030         id = soap_element_id(soap, tag, id, a, (struct soap_array*)&a->__ptr, 1, type, SOAP_TYPE_acq2xx__TransactionList);
04031         if (id < 0)
04032                 return soap->error;
04033         soap_element_begin_out(soap, tag, id, "acq2xx:TransactionList");
04034         for (i = 0; i < n; i++)
04035         {
04036                 soap_out_PointerToacq2xx__Transaction(soap, "acq2xx:item", -1, &a->__ptr[i], "acq2xx:Transaction");
04037         }
04038         soap_element_end_out(soap, tag);
04039         return SOAP_OK;
04040 }
04041 
04042 void *acq2xx__TransactionList::soap_get(struct soap *soap, const char *tag, const char *type)
04043 {
04044         return soap_get_acq2xx__TransactionList(soap, this, tag, type);
04045 }
04046 
04047 SOAP_FMAC3 acq2xx__TransactionList * SOAP_FMAC4 soap_get_acq2xx__TransactionList(struct soap *soap, acq2xx__TransactionList *p, const char *tag, const char *type)
04048 {
04049         if ((p = soap_in_acq2xx__TransactionList(soap, tag, p, type)))
04050                 soap_getindependent(soap);
04051         return p;
04052 }
04053 
04054 void *acq2xx__TransactionList::soap_in(struct soap *soap, const char *tag, const char *type)
04055 {       return soap_in_acq2xx__TransactionList(soap, tag, this, type);
04056 }
04057 
04058 SOAP_FMAC3 acq2xx__TransactionList * SOAP_FMAC4 soap_in_acq2xx__TransactionList(struct soap *soap, const char *tag, acq2xx__TransactionList *a, const char *type)
04059 {       int i, j;
04060         acq2xx__Transaction **p;
04061         if (soap_element_begin_in(soap, tag, 1, NULL))
04062                 return NULL;
04063         if (*soap->type && soap_match_tag(soap, soap->type, type))
04064         {       soap->error = SOAP_TYPE;
04065                 return NULL;
04066         }
04067         a = (acq2xx__TransactionList *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__TransactionList, sizeof(acq2xx__TransactionList), soap->type, soap->arrayType);
04068         if (!a)
04069                 return NULL;
04070         if (soap->alloced)
04071                 a->soap_default(soap);
04072         if (soap->body && !*soap->href)
04073         {
04074                 a->__size = soap_getsize(soap->arraySize, soap->arrayOffset, &j);
04075                 if (a->__size >= 0)
04076                 {       a->__ptr = (acq2xx__Transaction **)soap_malloc(soap, sizeof(acq2xx__Transaction *) * a->__size);
04077                         for (i = 0; i < a->__size; i++)
04078                                 a->__ptr[i] = NULL;
04079                         for (i = 0; i < a->__size; i++)
04080                         {       soap_peek_element(soap);
04081                                 if (soap->position)
04082                                 {       i = soap->positions[0]-j;
04083                                         if (i < 0 || i >= a->__size)
04084                                         {       soap->error = SOAP_IOB;
04085                                                 return NULL;
04086                                         }
04087                                 }
04088                                 if (!soap_in_PointerToacq2xx__Transaction(soap, NULL, a->__ptr + i, "acq2xx:Transaction"))
04089                                 {       if (soap->error != SOAP_NO_TAG)
04090                                                 return NULL;
04091                                         soap->error = SOAP_OK;
04092                                         break;
04093                                 }
04094                         }
04095                 }
04096                 else
04097                 {       soap_new_block(soap);
04098                         for (a->__size = 0; ; a->__size++)
04099                         {       p = (acq2xx__Transaction **)soap_push_block(soap, sizeof(acq2xx__Transaction *));
04100                                 if (!p)
04101                                         return NULL;
04102                                 *p = NULL;
04103                                 if (!soap_in_PointerToacq2xx__Transaction(soap, NULL, p, "acq2xx:Transaction"))
04104                                 {       if (soap->error != SOAP_NO_TAG)
04105                                                 return NULL;
04106                                         soap->error = SOAP_OK;
04107                                         break;
04108                                 }
04109                         }
04110                         soap_pop_block(soap);
04111                         a->__ptr = (acq2xx__Transaction **)soap_malloc(soap, soap->blist->size);
04112                         soap_save_block(soap, (char*)a->__ptr, 1);
04113                 }
04114                 if (soap_element_end_in(soap, tag))
04115                         return NULL;
04116         }
04117         else
04118         {       a = (acq2xx__TransactionList *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__TransactionList, 0, sizeof(acq2xx__TransactionList), 0, soap_copy_acq2xx__TransactionList);
04119                 if (soap->body && soap_element_end_in(soap, tag))
04120                         return NULL;
04121         }
04122         return a;
04123 }
04124 
04125 SOAP_FMAC5 acq2xx__TransactionList * SOAP_FMAC6 soap_new_acq2xx__TransactionList(struct soap *soap, int n)
04126 {       return soap_instantiate_acq2xx__TransactionList(soap, n, NULL, NULL, NULL);
04127 }
04128 
04129 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__TransactionList(struct soap *soap, acq2xx__TransactionList *p)
04130 {       soap_delete(soap, p);
04131 }
04132 
04133 SOAP_FMAC3 acq2xx__TransactionList * SOAP_FMAC4 soap_instantiate_acq2xx__TransactionList(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
04134 {
04135         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__TransactionList(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
04136         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__TransactionList, n, soap_fdelete);
04137         if (!cp)
04138                 return NULL;
04139         if (type && !soap_match_tag(soap, type, "acq2xx:AcqControlTransaction"))
04140         {       cp->type = SOAP_TYPE_acq2xx__AcqControlTransaction;
04141                 if (n < 0)
04142                 {       cp->ptr = (void*)new acq2xx__AcqControlTransaction;
04143                         if (size)
04144                                 *size = sizeof(acq2xx__AcqControlTransaction);
04145                 }
04146                 else
04147                 {       cp->ptr = (void*)new acq2xx__AcqControlTransaction[n];
04148                         if (size)
04149                                 *size = n * sizeof(acq2xx__AcqControlTransaction);
04150                 }
04151         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04152                 return (acq2xx__AcqControlTransaction*)cp->ptr;
04153         }
04154         if (n < 0)
04155         {       cp->ptr = (void*)new acq2xx__TransactionList;
04156                 if (size)
04157                         *size = sizeof(acq2xx__TransactionList);
04158         }
04159         else
04160         {       cp->ptr = (void*)new acq2xx__TransactionList[n];
04161                 if (size)
04162                         *size = n * sizeof(acq2xx__TransactionList);
04163         }
04164                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04165         return (acq2xx__TransactionList*)cp->ptr;
04166 }
04167 
04168 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__TransactionList(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
04169 {
04170         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__TransactionList %p -> %p\n", q, p));
04171         *(acq2xx__TransactionList*)p = *(acq2xx__TransactionList*)q;
04172 }
04173 
04174 void acq2xx__Transaction::soap_serialize(struct soap *soap) const
04175 {
04176         (void)soap; /* appease -Wall -Werror */
04177         /* transient acq2xx__Transaction skipped */
04178         /* transient acq2xx__Transaction skipped */
04179         /* transient ~acq2xx__Transaction skipped */
04180         /* transient print skipped */
04181         /* transient exec skipped */
04182         /* transient getCommand skipped */
04183         /* transient getResult skipped */
04184         /* transient run skipped */
04185         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
04186         /* transient acq2xx__Object skipped */
04187         /* transient acq2xx__Object skipped */
04188         /* transient ~acq2xx__Object skipped */
04189         /* transient print skipped */
04190         /* transient getName skipped */
04191 }
04192 
04193 void acq2xx__Transaction::soap_default(struct soap *soap)
04194 {
04195         (void)soap; /* appease -Wall -Werror */
04196         soap_default_int(soap, &((acq2xx__Transaction*)this)->abort_on_error);
04197         soap_default_int(soap, &((acq2xx__Transaction*)this)->status);
04198         soap_default_int(soap, &((acq2xx__Transaction*)this)->complete);
04199         /* transient acq2xx__Transaction skipped */
04200         /* transient acq2xx__Transaction skipped */
04201         /* transient ~acq2xx__Transaction skipped */
04202         /* transient print skipped */
04203         /* transient exec skipped */
04204         /* transient getCommand skipped */
04205         /* transient getResult skipped */
04206         /* transient run skipped */
04207         soap_default_string(soap, &((acq2xx__Object*)this)->name);
04208         /* transient acq2xx__Object skipped */
04209         /* transient acq2xx__Object skipped */
04210         /* transient ~acq2xx__Object skipped */
04211         /* transient print skipped */
04212         /* transient getName skipped */
04213 }
04214 
04215 int acq2xx__Transaction::soap_put(struct soap *soap, const char *tag, const  char *type) const
04216 {
04217         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__Transaction);
04218         if (this->soap_out(soap, tag, id, type))
04219                 return soap->error;
04220         return soap_putindependent(soap);
04221 }
04222 
04223 int acq2xx__Transaction::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
04224 {
04225         return soap_out_acq2xx__Transaction(soap, tag, id, this, type);
04226 }
04227 
04228 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__Transaction(struct soap *soap, const char *tag, int id, const acq2xx__Transaction *a, const char *type)
04229 {
04230         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__Transaction), "acq2xx:Transaction");
04231         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
04232         /* transient acq2xx__Object skipped */
04233         /* transient acq2xx__Object skipped */
04234         /* transient ~acq2xx__Object skipped */
04235         /* transient print skipped */
04236         /* transient getName skipped */
04237         soap_out_int(soap, "acq2xx:abort-on-error", -1, &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int");
04238         soap_out_int(soap, "acq2xx:status", -1, &(((acq2xx__Transaction*)a)->status), "xsd:int");
04239         soap_out_int(soap, "acq2xx:complete", -1, &(((acq2xx__Transaction*)a)->complete), "xsd:int");
04240         /* transient acq2xx__Transaction skipped */
04241         /* transient acq2xx__Transaction skipped */
04242         /* transient ~acq2xx__Transaction skipped */
04243         /* transient print skipped */
04244         /* transient exec skipped */
04245         /* transient getCommand skipped */
04246         /* transient getResult skipped */
04247         /* transient run skipped */
04248         soap_element_end_out(soap, tag);
04249         return SOAP_OK;
04250 }
04251 
04252 void *acq2xx__Transaction::soap_get(struct soap *soap, const char *tag, const char *type)
04253 {
04254         return soap_get_acq2xx__Transaction(soap, this, tag, type);
04255 }
04256 
04257 SOAP_FMAC3 acq2xx__Transaction * SOAP_FMAC4 soap_get_acq2xx__Transaction(struct soap *soap, acq2xx__Transaction *p, const char *tag, const char *type)
04258 {
04259         if ((p = soap_in_acq2xx__Transaction(soap, tag, p, type)))
04260                 soap_getindependent(soap);
04261         return p;
04262 }
04263 
04264 void *acq2xx__Transaction::soap_in(struct soap *soap, const char *tag, const char *type)
04265 {       return soap_in_acq2xx__Transaction(soap, tag, this, type);
04266 }
04267 
04268 SOAP_FMAC3 acq2xx__Transaction * SOAP_FMAC4 soap_in_acq2xx__Transaction(struct soap *soap, const char *tag, acq2xx__Transaction *a, const char *type)
04269 {
04270         if (soap_element_begin_in(soap, tag, 0, NULL))
04271                 return NULL;
04272         a = (acq2xx__Transaction *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__Transaction, sizeof(acq2xx__Transaction), soap->type, soap->arrayType);
04273         if (!a)
04274                 return NULL;
04275         if (soap->alloced)
04276         {       a->soap_default(soap);
04277                 if (soap->clist->type != SOAP_TYPE_acq2xx__Transaction)
04278                 {       soap_revert(soap);
04279                         *soap->id = '\0';
04280                         return (acq2xx__Transaction *)a->soap_in(soap, tag, type);
04281                 }
04282         }
04283         short soap_flag_name2 = 1, soap_flag_abort_on_error1 = 1, soap_flag_status1 = 1, soap_flag_complete1 = 1;
04284         if (soap->body && !*soap->href)
04285         {
04286                 for (;;)
04287                 {       soap->error = SOAP_TAG_MISMATCH;
04288                         if (soap_flag_name2 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
04289                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
04290                                 {       soap_flag_name2--;
04291                                         continue;
04292                                 }
04293                         /* transient acq2xx__Object skipped */
04294                         /* transient acq2xx__Object skipped */
04295                         /* transient ~acq2xx__Object skipped */
04296                         /* transient print skipped */
04297                         /* transient getName skipped */
04298                         if (soap_flag_abort_on_error1 && soap->error == SOAP_TAG_MISMATCH)
04299                                 if (soap_in_int(soap, "acq2xx:abort-on-error", &(((acq2xx__Transaction*)a)->abort_on_error), "xsd:int"))
04300                                 {       soap_flag_abort_on_error1--;
04301                                         continue;
04302                                 }
04303                         if (soap_flag_status1 && soap->error == SOAP_TAG_MISMATCH)
04304                                 if (soap_in_int(soap, "acq2xx:status", &(((acq2xx__Transaction*)a)->status), "xsd:int"))
04305                                 {       soap_flag_status1--;
04306                                         continue;
04307                                 }
04308                         if (soap_flag_complete1 && soap->error == SOAP_TAG_MISMATCH)
04309                                 if (soap_in_int(soap, "acq2xx:complete", &(((acq2xx__Transaction*)a)->complete), "xsd:int"))
04310                                 {       soap_flag_complete1--;
04311                                         continue;
04312                                 }
04313                         /* transient acq2xx__Transaction skipped */
04314                         /* transient acq2xx__Transaction skipped */
04315                         /* transient ~acq2xx__Transaction skipped */
04316                         /* transient print skipped */
04317                         /* transient exec skipped */
04318                         /* transient getCommand skipped */
04319                         /* transient getResult skipped */
04320                         /* transient run skipped */
04321                         if (soap->error == SOAP_TAG_MISMATCH)
04322                                 soap->error = soap_ignore_element(soap);
04323                         if (soap->error == SOAP_NO_TAG)
04324                                 break;
04325                         if (soap->error)
04326                                 return NULL;
04327                 }
04328                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_abort_on_error1 > 0 || soap_flag_status1 > 0 || soap_flag_complete1 > 0))
04329                 {       soap->error = SOAP_OCCURS;
04330                         return NULL;
04331                 }
04332                 if (soap_element_end_in(soap, tag))
04333                         return NULL;
04334         }
04335         else
04336         {       a = (acq2xx__Transaction *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__Transaction, 0, sizeof(acq2xx__Transaction), 0, soap_copy_acq2xx__Transaction);
04337                 if (soap->body && soap_element_end_in(soap, tag))
04338                         return NULL;
04339         }
04340         return a;
04341 }
04342 
04343 SOAP_FMAC5 acq2xx__Transaction * SOAP_FMAC6 soap_new_acq2xx__Transaction(struct soap *soap, int n)
04344 {       return soap_instantiate_acq2xx__Transaction(soap, n, NULL, NULL, NULL);
04345 }
04346 
04347 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__Transaction(struct soap *soap, acq2xx__Transaction *p)
04348 {       soap_delete(soap, p);
04349 }
04350 
04351 SOAP_FMAC3 acq2xx__Transaction * SOAP_FMAC4 soap_instantiate_acq2xx__Transaction(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
04352 {
04353         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__Transaction(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
04354         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__Transaction, n, soap_fdelete);
04355         if (!cp)
04356                 return NULL;
04357         if (type && !soap_match_tag(soap, type, "acq2xx:TransactionList"))
04358         {       cp->type = SOAP_TYPE_acq2xx__TransactionList;
04359                 if (n < 0)
04360                 {       cp->ptr = (void*)new acq2xx__TransactionList;
04361                         if (size)
04362                                 *size = sizeof(acq2xx__TransactionList);
04363                 }
04364                 else
04365                 {       cp->ptr = (void*)new acq2xx__TransactionList[n];
04366                         if (size)
04367                                 *size = n * sizeof(acq2xx__TransactionList);
04368                 }
04369         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04370                 return (acq2xx__TransactionList*)cp->ptr;
04371         }
04372         if (type && !soap_match_tag(soap, type, "acq2xx:ShellTransaction"))
04373         {       cp->type = SOAP_TYPE_acq2xx__ShellTransaction;
04374                 if (n < 0)
04375                 {       cp->ptr = (void*)new acq2xx__ShellTransaction;
04376                         if (size)
04377                                 *size = sizeof(acq2xx__ShellTransaction);
04378                 }
04379                 else
04380                 {       cp->ptr = (void*)new acq2xx__ShellTransaction[n];
04381                         if (size)
04382                                 *size = n * sizeof(acq2xx__ShellTransaction);
04383                 }
04384         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04385                 return (acq2xx__ShellTransaction*)cp->ptr;
04386         }
04387         if (type && !soap_match_tag(soap, type, "acq2xx:ModeSetTransaction"))
04388         {       cp->type = SOAP_TYPE_acq2xx__ModeSetTransaction;
04389                 if (n < 0)
04390                 {       cp->ptr = (void*)new acq2xx__ModeSetTransaction;
04391                         if (size)
04392                                 *size = sizeof(acq2xx__ModeSetTransaction);
04393                 }
04394                 else
04395                 {       cp->ptr = (void*)new acq2xx__ModeSetTransaction[n];
04396                         if (size)
04397                                 *size = n * sizeof(acq2xx__ModeSetTransaction);
04398                 }
04399         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04400                 return (acq2xx__ModeSetTransaction*)cp->ptr;
04401         }
04402         if (type && !soap_match_tag(soap, type, "acq2xx:ClockSetTransaction"))
04403         {       cp->type = SOAP_TYPE_acq2xx__ClockSetTransaction;
04404                 if (n < 0)
04405                 {       cp->ptr = (void*)new acq2xx__ClockSetTransaction;
04406                         if (size)
04407                                 *size = sizeof(acq2xx__ClockSetTransaction);
04408                 }
04409                 else
04410                 {       cp->ptr = (void*)new acq2xx__ClockSetTransaction[n];
04411                         if (size)
04412                                 *size = n * sizeof(acq2xx__ClockSetTransaction);
04413                 }
04414         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04415                 return (acq2xx__ClockSetTransaction*)cp->ptr;
04416         }
04417         if (type && !soap_match_tag(soap, type, "acq2xx:InternalClockSetTransaction"))
04418         {       cp->type = SOAP_TYPE_acq2xx__InternalClockSetTransaction;
04419                 if (n < 0)
04420                 {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction;
04421                         if (size)
04422                                 *size = sizeof(acq2xx__InternalClockSetTransaction);
04423                 }
04424                 else
04425                 {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction[n];
04426                         if (size)
04427                                 *size = n * sizeof(acq2xx__InternalClockSetTransaction);
04428                 }
04429         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04430                 return (acq2xx__InternalClockSetTransaction*)cp->ptr;
04431         }
04432         if (type && !soap_match_tag(soap, type, "acq2xx:ExternalClockSetTransaction"))
04433         {       cp->type = SOAP_TYPE_acq2xx__ExternalClockSetTransaction;
04434                 if (n < 0)
04435                 {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction;
04436                         if (size)
04437                                 *size = sizeof(acq2xx__ExternalClockSetTransaction);
04438                 }
04439                 else
04440                 {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction[n];
04441                         if (size)
04442                                 *size = n * sizeof(acq2xx__ExternalClockSetTransaction);
04443                 }
04444         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04445                 return (acq2xx__ExternalClockSetTransaction*)cp->ptr;
04446         }
04447         if (type && !soap_match_tag(soap, type, "acq2xx:SignalSetTransaction"))
04448         {       cp->type = SOAP_TYPE_acq2xx__SignalSetTransaction;
04449                 if (n < 0)
04450                 {       cp->ptr = (void*)new acq2xx__SignalSetTransaction;
04451                         if (size)
04452                                 *size = sizeof(acq2xx__SignalSetTransaction);
04453                 }
04454                 else
04455                 {       cp->ptr = (void*)new acq2xx__SignalSetTransaction[n];
04456                         if (size)
04457                                 *size = n * sizeof(acq2xx__SignalSetTransaction);
04458                 }
04459         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04460                 return (acq2xx__SignalSetTransaction*)cp->ptr;
04461         }
04462         if (type && !soap_match_tag(soap, type, "acq2xx:AcqControlTransaction"))
04463         {       cp->type = SOAP_TYPE_acq2xx__AcqControlTransaction;
04464                 if (n < 0)
04465                 {       cp->ptr = (void*)new acq2xx__AcqControlTransaction;
04466                         if (size)
04467                                 *size = sizeof(acq2xx__AcqControlTransaction);
04468                 }
04469                 else
04470                 {       cp->ptr = (void*)new acq2xx__AcqControlTransaction[n];
04471                         if (size)
04472                                 *size = n * sizeof(acq2xx__AcqControlTransaction);
04473                 }
04474         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04475                 return (acq2xx__AcqControlTransaction*)cp->ptr;
04476         }
04477         if (type && !soap_match_tag(soap, type, "acq2xx:GetAvailableChannelsTransaction"))
04478         {       cp->type = SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction;
04479                 if (n < 0)
04480                 {       cp->ptr = (void*)new acq2xx__GetAvailableChannelsTransaction;
04481                         if (size)
04482                                 *size = sizeof(acq2xx__GetAvailableChannelsTransaction);
04483                 }
04484                 else
04485                 {       cp->ptr = (void*)new acq2xx__GetAvailableChannelsTransaction[n];
04486                         if (size)
04487                                 *size = n * sizeof(acq2xx__GetAvailableChannelsTransaction);
04488                 }
04489         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04490                 return (acq2xx__GetAvailableChannelsTransaction*)cp->ptr;
04491         }
04492         if (type && !soap_match_tag(soap, type, "acq2xx:GetVRangeTransaction"))
04493         {       cp->type = SOAP_TYPE_acq2xx__GetVRangeTransaction;
04494                 if (n < 0)
04495                 {       cp->ptr = (void*)new acq2xx__GetVRangeTransaction;
04496                         if (size)
04497                                 *size = sizeof(acq2xx__GetVRangeTransaction);
04498                 }
04499                 else
04500                 {       cp->ptr = (void*)new acq2xx__GetVRangeTransaction[n];
04501                         if (size)
04502                                 *size = n * sizeof(acq2xx__GetVRangeTransaction);
04503                 }
04504         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04505                 return (acq2xx__GetVRangeTransaction*)cp->ptr;
04506         }
04507         if (n < 0)
04508         {       cp->ptr = (void*)new acq2xx__Transaction;
04509                 if (size)
04510                         *size = sizeof(acq2xx__Transaction);
04511         }
04512         else
04513         {       cp->ptr = (void*)new acq2xx__Transaction[n];
04514                 if (size)
04515                         *size = n * sizeof(acq2xx__Transaction);
04516         }
04517                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04518         return (acq2xx__Transaction*)cp->ptr;
04519 }
04520 
04521 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__Transaction(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
04522 {
04523         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__Transaction %p -> %p\n", q, p));
04524         *(acq2xx__Transaction*)p = *(acq2xx__Transaction*)q;
04525 }
04526 
04527 void acq2xx__Object::soap_serialize(struct soap *soap) const
04528 {
04529         (void)soap; /* appease -Wall -Werror */
04530         soap_serialize_string(soap, &((acq2xx__Object*)this)->name);
04531         /* transient acq2xx__Object skipped */
04532         /* transient acq2xx__Object skipped */
04533         /* transient ~acq2xx__Object skipped */
04534         /* transient print skipped */
04535         /* transient getName skipped */
04536 }
04537 
04538 void acq2xx__Object::soap_default(struct soap *soap)
04539 {
04540         (void)soap; /* appease -Wall -Werror */
04541         soap_default_string(soap, &((acq2xx__Object*)this)->name);
04542         /* transient acq2xx__Object skipped */
04543         /* transient acq2xx__Object skipped */
04544         /* transient ~acq2xx__Object skipped */
04545         /* transient print skipped */
04546         /* transient getName skipped */
04547 }
04548 
04549 int acq2xx__Object::soap_put(struct soap *soap, const char *tag, const  char *type) const
04550 {
04551         register int id = soap_embed(soap, (void*)this, NULL, 0, tag, SOAP_TYPE_acq2xx__Object);
04552         if (this->soap_out(soap, tag, id, type))
04553                 return soap->error;
04554         return soap_putindependent(soap);
04555 }
04556 
04557 int acq2xx__Object::soap_out(struct soap *soap, const char *tag, int id, const char *type) const
04558 {
04559         return soap_out_acq2xx__Object(soap, tag, id, this, type);
04560 }
04561 
04562 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__Object(struct soap *soap, const char *tag, int id, const acq2xx__Object *a, const char *type)
04563 {
04564         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__Object), type);
04565         soap_out_string(soap, "acq2xx:name", -1, &(((acq2xx__Object*)a)->name), "xsd:string");
04566         /* transient acq2xx__Object skipped */
04567         /* transient acq2xx__Object skipped */
04568         /* transient ~acq2xx__Object skipped */
04569         /* transient print skipped */
04570         /* transient getName skipped */
04571         soap_element_end_out(soap, tag);
04572         return SOAP_OK;
04573 }
04574 
04575 void *acq2xx__Object::soap_get(struct soap *soap, const char *tag, const char *type)
04576 {
04577         return soap_get_acq2xx__Object(soap, this, tag, type);
04578 }
04579 
04580 SOAP_FMAC3 acq2xx__Object * SOAP_FMAC4 soap_get_acq2xx__Object(struct soap *soap, acq2xx__Object *p, const char *tag, const char *type)
04581 {
04582         if ((p = soap_in_acq2xx__Object(soap, tag, p, type)))
04583                 soap_getindependent(soap);
04584         return p;
04585 }
04586 
04587 void *acq2xx__Object::soap_in(struct soap *soap, const char *tag, const char *type)
04588 {       return soap_in_acq2xx__Object(soap, tag, this, type);
04589 }
04590 
04591 SOAP_FMAC3 acq2xx__Object * SOAP_FMAC4 soap_in_acq2xx__Object(struct soap *soap, const char *tag, acq2xx__Object *a, const char *type)
04592 {
04593         if (soap_element_begin_in(soap, tag, 0, NULL))
04594                 return NULL;
04595         a = (acq2xx__Object *)soap_class_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__Object, sizeof(acq2xx__Object), soap->type, soap->arrayType);
04596         if (!a)
04597                 return NULL;
04598         if (soap->alloced)
04599         {       a->soap_default(soap);
04600                 if (soap->clist->type != SOAP_TYPE_acq2xx__Object)
04601                 {       soap_revert(soap);
04602                         *soap->id = '\0';
04603                         return (acq2xx__Object *)a->soap_in(soap, tag, type);
04604                 }
04605         }
04606         short soap_flag_name1 = 1;
04607         if (soap->body && !*soap->href)
04608         {
04609                 for (;;)
04610                 {       soap->error = SOAP_TAG_MISMATCH;
04611                         if (soap_flag_name1 && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
04612                                 if (soap_in_string(soap, "acq2xx:name", &(((acq2xx__Object*)a)->name), "xsd:string"))
04613                                 {       soap_flag_name1--;
04614                                         continue;
04615                                 }
04616                         /* transient acq2xx__Object skipped */
04617                         /* transient acq2xx__Object skipped */
04618                         /* transient ~acq2xx__Object skipped */
04619                         /* transient print skipped */
04620                         /* transient getName skipped */
04621                         if (soap->error == SOAP_TAG_MISMATCH)
04622                                 soap->error = soap_ignore_element(soap);
04623                         if (soap->error == SOAP_NO_TAG)
04624                                 break;
04625                         if (soap->error)
04626                                 return NULL;
04627                 }
04628                 if (soap_element_end_in(soap, tag))
04629                         return NULL;
04630         }
04631         else
04632         {       a = (acq2xx__Object *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__Object, 0, sizeof(acq2xx__Object), 0, soap_copy_acq2xx__Object);
04633                 if (soap->body && soap_element_end_in(soap, tag))
04634                         return NULL;
04635         }
04636         return a;
04637 }
04638 
04639 SOAP_FMAC5 acq2xx__Object * SOAP_FMAC6 soap_new_acq2xx__Object(struct soap *soap, int n)
04640 {       return soap_instantiate_acq2xx__Object(soap, n, NULL, NULL, NULL);
04641 }
04642 
04643 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__Object(struct soap *soap, acq2xx__Object *p)
04644 {       soap_delete(soap, p);
04645 }
04646 
04647 SOAP_FMAC3 acq2xx__Object * SOAP_FMAC4 soap_instantiate_acq2xx__Object(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
04648 {
04649         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__Object(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
04650         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__Object, n, soap_fdelete);
04651         if (!cp)
04652                 return NULL;
04653         if (type && !soap_match_tag(soap, type, "acq2xx:Transaction"))
04654         {       cp->type = SOAP_TYPE_acq2xx__Transaction;
04655                 if (n < 0)
04656                 {       cp->ptr = (void*)new acq2xx__Transaction;
04657                         if (size)
04658                                 *size = sizeof(acq2xx__Transaction);
04659                 }
04660                 else
04661                 {       cp->ptr = (void*)new acq2xx__Transaction[n];
04662                         if (size)
04663                                 *size = n * sizeof(acq2xx__Transaction);
04664                 }
04665         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04666                 return (acq2xx__Transaction*)cp->ptr;
04667         }
04668         if (type && !soap_match_tag(soap, type, "acq2xx:TransactionList"))
04669         {       cp->type = SOAP_TYPE_acq2xx__TransactionList;
04670                 if (n < 0)
04671                 {       cp->ptr = (void*)new acq2xx__TransactionList;
04672                         if (size)
04673                                 *size = sizeof(acq2xx__TransactionList);
04674                 }
04675                 else
04676                 {       cp->ptr = (void*)new acq2xx__TransactionList[n];
04677                         if (size)
04678                                 *size = n * sizeof(acq2xx__TransactionList);
04679                 }
04680         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04681                 return (acq2xx__TransactionList*)cp->ptr;
04682         }
04683         if (type && !soap_match_tag(soap, type, "acq2xx:ShellTransaction"))
04684         {       cp->type = SOAP_TYPE_acq2xx__ShellTransaction;
04685                 if (n < 0)
04686                 {       cp->ptr = (void*)new acq2xx__ShellTransaction;
04687                         if (size)
04688                                 *size = sizeof(acq2xx__ShellTransaction);
04689                 }
04690                 else
04691                 {       cp->ptr = (void*)new acq2xx__ShellTransaction[n];
04692                         if (size)
04693                                 *size = n * sizeof(acq2xx__ShellTransaction);
04694                 }
04695         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04696                 return (acq2xx__ShellTransaction*)cp->ptr;
04697         }
04698         if (type && !soap_match_tag(soap, type, "acq2xx:ModeSetTransaction"))
04699         {       cp->type = SOAP_TYPE_acq2xx__ModeSetTransaction;
04700                 if (n < 0)
04701                 {       cp->ptr = (void*)new acq2xx__ModeSetTransaction;
04702                         if (size)
04703                                 *size = sizeof(acq2xx__ModeSetTransaction);
04704                 }
04705                 else
04706                 {       cp->ptr = (void*)new acq2xx__ModeSetTransaction[n];
04707                         if (size)
04708                                 *size = n * sizeof(acq2xx__ModeSetTransaction);
04709                 }
04710         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04711                 return (acq2xx__ModeSetTransaction*)cp->ptr;
04712         }
04713         if (type && !soap_match_tag(soap, type, "acq2xx:ClockSetTransaction"))
04714         {       cp->type = SOAP_TYPE_acq2xx__ClockSetTransaction;
04715                 if (n < 0)
04716                 {       cp->ptr = (void*)new acq2xx__ClockSetTransaction;
04717                         if (size)
04718                                 *size = sizeof(acq2xx__ClockSetTransaction);
04719                 }
04720                 else
04721                 {       cp->ptr = (void*)new acq2xx__ClockSetTransaction[n];
04722                         if (size)
04723                                 *size = n * sizeof(acq2xx__ClockSetTransaction);
04724                 }
04725         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04726                 return (acq2xx__ClockSetTransaction*)cp->ptr;
04727         }
04728         if (type && !soap_match_tag(soap, type, "acq2xx:InternalClockSetTransaction"))
04729         {       cp->type = SOAP_TYPE_acq2xx__InternalClockSetTransaction;
04730                 if (n < 0)
04731                 {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction;
04732                         if (size)
04733                                 *size = sizeof(acq2xx__InternalClockSetTransaction);
04734                 }
04735                 else
04736                 {       cp->ptr = (void*)new acq2xx__InternalClockSetTransaction[n];
04737                         if (size)
04738                                 *size = n * sizeof(acq2xx__InternalClockSetTransaction);
04739                 }
04740         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04741                 return (acq2xx__InternalClockSetTransaction*)cp->ptr;
04742         }
04743         if (type && !soap_match_tag(soap, type, "acq2xx:ExternalClockSetTransaction"))
04744         {       cp->type = SOAP_TYPE_acq2xx__ExternalClockSetTransaction;
04745                 if (n < 0)
04746                 {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction;
04747                         if (size)
04748                                 *size = sizeof(acq2xx__ExternalClockSetTransaction);
04749                 }
04750                 else
04751                 {       cp->ptr = (void*)new acq2xx__ExternalClockSetTransaction[n];
04752                         if (size)
04753                                 *size = n * sizeof(acq2xx__ExternalClockSetTransaction);
04754                 }
04755         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04756                 return (acq2xx__ExternalClockSetTransaction*)cp->ptr;
04757         }
04758         if (type && !soap_match_tag(soap, type, "acq2xx:SignalSetTransaction"))
04759         {       cp->type = SOAP_TYPE_acq2xx__SignalSetTransaction;
04760                 if (n < 0)
04761                 {       cp->ptr = (void*)new acq2xx__SignalSetTransaction;
04762                         if (size)
04763                                 *size = sizeof(acq2xx__SignalSetTransaction);
04764                 }
04765                 else
04766                 {       cp->ptr = (void*)new acq2xx__SignalSetTransaction[n];
04767                         if (size)
04768                                 *size = n * sizeof(acq2xx__SignalSetTransaction);
04769                 }
04770         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04771                 return (acq2xx__SignalSetTransaction*)cp->ptr;
04772         }
04773         if (type && !soap_match_tag(soap, type, "acq2xx:AcqControlTransaction"))
04774         {       cp->type = SOAP_TYPE_acq2xx__AcqControlTransaction;
04775                 if (n < 0)
04776                 {       cp->ptr = (void*)new acq2xx__AcqControlTransaction;
04777                         if (size)
04778                                 *size = sizeof(acq2xx__AcqControlTransaction);
04779                 }
04780                 else
04781                 {       cp->ptr = (void*)new acq2xx__AcqControlTransaction[n];
04782                         if (size)
04783                                 *size = n * sizeof(acq2xx__AcqControlTransaction);
04784                 }
04785         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04786                 return (acq2xx__AcqControlTransaction*)cp->ptr;
04787         }
04788         if (type && !soap_match_tag(soap, type, "acq2xx:GetAvailableChannelsTransaction"))
04789         {       cp->type = SOAP_TYPE_acq2xx__GetAvailableChannelsTransaction;
04790                 if (n < 0)
04791                 {       cp->ptr = (void*)new acq2xx__GetAvailableChannelsTransaction;
04792                         if (size)
04793                                 *size = sizeof(acq2xx__GetAvailableChannelsTransaction);
04794                 }
04795                 else
04796                 {       cp->ptr = (void*)new acq2xx__GetAvailableChannelsTransaction[n];
04797                         if (size)
04798                                 *size = n * sizeof(acq2xx__GetAvailableChannelsTransaction);
04799                 }
04800         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04801                 return (acq2xx__GetAvailableChannelsTransaction*)cp->ptr;
04802         }
04803         if (type && !soap_match_tag(soap, type, "acq2xx:GetVRangeTransaction"))
04804         {       cp->type = SOAP_TYPE_acq2xx__GetVRangeTransaction;
04805                 if (n < 0)
04806                 {       cp->ptr = (void*)new acq2xx__GetVRangeTransaction;
04807                         if (size)
04808                                 *size = sizeof(acq2xx__GetVRangeTransaction);
04809                 }
04810                 else
04811                 {       cp->ptr = (void*)new acq2xx__GetVRangeTransaction[n];
04812                         if (size)
04813                                 *size = n * sizeof(acq2xx__GetVRangeTransaction);
04814                 }
04815         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04816                 return (acq2xx__GetVRangeTransaction*)cp->ptr;
04817         }
04818         if (n < 0)
04819         {       cp->ptr = (void*)new acq2xx__Object;
04820                 if (size)
04821                         *size = sizeof(acq2xx__Object);
04822         }
04823         else
04824         {       cp->ptr = (void*)new acq2xx__Object[n];
04825                 if (size)
04826                         *size = n * sizeof(acq2xx__Object);
04827         }
04828                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
04829         return (acq2xx__Object*)cp->ptr;
04830 }
04831 
04832 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__Object(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
04833 {
04834         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying acq2xx__Object %p -> %p\n", q, p));
04835         *(acq2xx__Object*)p = *(acq2xx__Object*)q;
04836 }
04837 
04838 #ifndef WITH_NOGLOBAL
04839 
04840 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
04841 {
04842         (void)soap; (void)a; /* appease -Wall -Werror */
04843         soap_serialize__QName(soap, &a->faultcode);
04844         soap_serialize_string(soap, &a->faultstring);
04845         soap_serialize_string(soap, &a->faultactor);
04846         soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
04847         soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
04848         soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
04849         soap_serialize_string(soap, &a->SOAP_ENV__Node);
04850         soap_serialize_string(soap, &a->SOAP_ENV__Role);
04851         soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
04852 }
04853 
04854 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
04855 {
04856         (void)soap; (void)a; /* appease -Wall -Werror */
04857         soap_default__QName(soap, &a->faultcode);
04858         soap_default_string(soap, &a->faultstring);
04859         soap_default_string(soap, &a->faultactor);
04860         a->detail = NULL;
04861         a->SOAP_ENV__Code = NULL;
04862         a->SOAP_ENV__Reason = NULL;
04863         soap_default_string(soap, &a->SOAP_ENV__Node);
04864         soap_default_string(soap, &a->SOAP_ENV__Role);
04865         a->SOAP_ENV__Detail = NULL;
04866 }
04867 
04868 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)
04869 {
04870         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Fault);
04871         if (soap_out_SOAP_ENV__Fault(soap, tag, id, a, type))
04872                 return soap->error;
04873         return soap_putindependent(soap);
04874 }
04875 
04876 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)
04877 {
04878         const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
04879         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Fault), type);
04880         soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, "");
04881         soap_out_string(soap, "faultstring", -1, &a->faultstring, "xsd:string");
04882         soap_out_string(soap, "faultactor", -1, &a->faultactor, "xsd:string");
04883         soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, "");
04884         soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, "");
04885         soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, "");
04886         soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, "");
04887         soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, "");
04888         soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, "");
04889         soap_element_end_out(soap, tag);
04890         return SOAP_OK;
04891 }
04892 
04893 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)
04894 {
04895         if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
04896                 soap_getindependent(soap);
04897         return p;
04898 }
04899 
04900 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)
04901 {
04902         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;
04903         if (soap_element_begin_in(soap, tag, 0, type))
04904                 return NULL;
04905         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);
04906         if (!a)
04907                 return NULL;
04908         soap_default_SOAP_ENV__Fault(soap, a);
04909         if (soap->body && !*soap->href)
04910         {
04911                 for (;;)
04912                 {       soap->error = SOAP_TAG_MISMATCH;
04913                         if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
04914                                 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
04915                                 {       soap_flag_faultcode--;
04916                                         continue;
04917                                 }
04918                         if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
04919                                 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
04920                                 {       soap_flag_faultstring--;
04921                                         continue;
04922                                 }
04923                         if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
04924                                 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
04925                                 {       soap_flag_faultactor--;
04926                                         continue;
04927                                 }
04928                         if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
04929                                 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
04930                                 {       soap_flag_detail--;
04931                                         continue;
04932                                 }
04933                         if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
04934                                 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
04935                                 {       soap_flag_SOAP_ENV__Code--;
04936                                         continue;
04937                                 }
04938                         if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
04939                                 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
04940                                 {       soap_flag_SOAP_ENV__Reason--;
04941                                         continue;
04942                                 }
04943                         if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
04944                                 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
04945                                 {       soap_flag_SOAP_ENV__Node--;
04946                                         continue;
04947                                 }
04948                         if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
04949                                 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
04950                                 {       soap_flag_SOAP_ENV__Role--;
04951                                         continue;
04952                                 }
04953                         if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
04954                                 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
04955                                 {       soap_flag_SOAP_ENV__Detail--;
04956                                         continue;
04957                                 }
04958                         if (soap->error == SOAP_TAG_MISMATCH)
04959                                 soap->error = soap_ignore_element(soap);
04960                         if (soap->error == SOAP_NO_TAG)
04961                                 break;
04962                         if (soap->error)
04963                                 return NULL;
04964                 }
04965                 if (soap_element_end_in(soap, tag))
04966                         return NULL;
04967         }
04968         else
04969         {       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);
04970                 if (soap->body && soap_element_end_in(soap, tag))
04971                         return NULL;
04972         }
04973         return a;
04974 }
04975 
04976 SOAP_FMAC5 struct SOAP_ENV__Fault * SOAP_FMAC6 soap_new_SOAP_ENV__Fault(struct soap *soap, int n)
04977 {       return soap_instantiate_SOAP_ENV__Fault(soap, n, NULL, NULL, NULL);
04978 }
04979 
04980 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *p)
04981 {       soap_delete(soap, p);
04982 }
04983 
04984 SOAP_FMAC3 struct SOAP_ENV__Fault * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Fault(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
04985 {
04986         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Fault(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
04987         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Fault, n, soap_fdelete);
04988         if (!cp)
04989                 return NULL;
04990         if (n < 0)
04991         {       cp->ptr = (void*)new struct SOAP_ENV__Fault;
04992                 if (size)
04993                         *size = sizeof(struct SOAP_ENV__Fault);
04994         }
04995         else
04996         {       cp->ptr = (void*)new struct SOAP_ENV__Fault[n];
04997                 if (size)
04998                         *size = n * sizeof(struct SOAP_ENV__Fault);
04999         }
05000                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05001         return (struct SOAP_ENV__Fault*)cp->ptr;
05002 }
05003 
05004 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Fault(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05005 {
05006         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Fault %p -> %p\n", q, p));
05007         *(struct SOAP_ENV__Fault*)p = *(struct SOAP_ENV__Fault*)q;
05008 }
05009 
05010 #endif
05011 
05012 #ifndef WITH_NOGLOBAL
05013 
05014 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
05015 {
05016         (void)soap; (void)a; /* appease -Wall -Werror */
05017         soap_serialize_string(soap, &a->SOAP_ENV__Text);
05018 }
05019 
05020 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
05021 {
05022         (void)soap; (void)a; /* appease -Wall -Werror */
05023         soap_default_string(soap, &a->SOAP_ENV__Text);
05024 }
05025 
05026 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)
05027 {
05028         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Reason);
05029         if (soap_out_SOAP_ENV__Reason(soap, tag, id, a, type))
05030                 return soap->error;
05031         return soap_putindependent(soap);
05032 }
05033 
05034 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)
05035 {
05036         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Reason), type);
05037         soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, "");
05038         soap_element_end_out(soap, tag);
05039         return SOAP_OK;
05040 }
05041 
05042 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)
05043 {
05044         if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
05045                 soap_getindependent(soap);
05046         return p;
05047 }
05048 
05049 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)
05050 {
05051         short soap_flag_SOAP_ENV__Text = 1;
05052         if (soap_element_begin_in(soap, tag, 0, type))
05053                 return NULL;
05054         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);
05055         if (!a)
05056                 return NULL;
05057         soap_default_SOAP_ENV__Reason(soap, a);
05058         if (soap->body && !*soap->href)
05059         {
05060                 for (;;)
05061                 {       soap->error = SOAP_TAG_MISMATCH;
05062                         if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
05063                                 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
05064                                 {       soap_flag_SOAP_ENV__Text--;
05065                                         continue;
05066                                 }
05067                         if (soap->error == SOAP_TAG_MISMATCH)
05068                                 soap->error = soap_ignore_element(soap);
05069                         if (soap->error == SOAP_NO_TAG)
05070                                 break;
05071                         if (soap->error)
05072                                 return NULL;
05073                 }
05074                 if (soap_element_end_in(soap, tag))
05075                         return NULL;
05076         }
05077         else
05078         {       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);
05079                 if (soap->body && soap_element_end_in(soap, tag))
05080                         return NULL;
05081         }
05082         return a;
05083 }
05084 
05085 SOAP_FMAC5 struct SOAP_ENV__Reason * SOAP_FMAC6 soap_new_SOAP_ENV__Reason(struct soap *soap, int n)
05086 {       return soap_instantiate_SOAP_ENV__Reason(soap, n, NULL, NULL, NULL);
05087 }
05088 
05089 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *p)
05090 {       soap_delete(soap, p);
05091 }
05092 
05093 SOAP_FMAC3 struct SOAP_ENV__Reason * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Reason(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
05094 {
05095         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Reason(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
05096         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Reason, n, soap_fdelete);
05097         if (!cp)
05098                 return NULL;
05099         if (n < 0)
05100         {       cp->ptr = (void*)new struct SOAP_ENV__Reason;
05101                 if (size)
05102                         *size = sizeof(struct SOAP_ENV__Reason);
05103         }
05104         else
05105         {       cp->ptr = (void*)new struct SOAP_ENV__Reason[n];
05106                 if (size)
05107                         *size = n * sizeof(struct SOAP_ENV__Reason);
05108         }
05109                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05110         return (struct SOAP_ENV__Reason*)cp->ptr;
05111 }
05112 
05113 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Reason(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05114 {
05115         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Reason %p -> %p\n", q, p));
05116         *(struct SOAP_ENV__Reason*)p = *(struct SOAP_ENV__Reason*)q;
05117 }
05118 
05119 #endif
05120 
05121 #ifndef WITH_NOGLOBAL
05122 
05123 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
05124 {
05125         (void)soap; (void)a; /* appease -Wall -Werror */
05126         soap_markelement(soap, a->fault, a->__type);
05127 }
05128 
05129 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
05130 {
05131         (void)soap; (void)a; /* appease -Wall -Werror */
05132         a->__type = 0;
05133         a->fault = NULL;
05134         a->__any = NULL;
05135 }
05136 
05137 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)
05138 {
05139         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Detail);
05140         if (soap_out_SOAP_ENV__Detail(soap, tag, id, a, type))
05141                 return soap->error;
05142         return soap_putindependent(soap);
05143 }
05144 
05145 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)
05146 {
05147         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Detail), type);
05148         soap_putelement(soap, a->fault, "fault", -1, a->__type);
05149         soap_outliteral(soap, "-any", &a->__any, NULL);
05150         soap_element_end_out(soap, tag);
05151         return SOAP_OK;
05152 }
05153 
05154 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)
05155 {
05156         if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
05157                 soap_getindependent(soap);
05158         return p;
05159 }
05160 
05161 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)
05162 {
05163         short soap_flag_fault = 1, soap_flag___any = 1;
05164         if (soap_element_begin_in(soap, tag, 0, type))
05165                 return NULL;
05166         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);
05167         if (!a)
05168                 return NULL;
05169         soap_default_SOAP_ENV__Detail(soap, a);
05170         if (soap->body && !*soap->href)
05171         {
05172                 for (;;)
05173                 {       soap->error = SOAP_TAG_MISMATCH;
05174                         if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
05175                                 if ((a->fault = soap_getelement(soap, &a->__type)))
05176                                 {       soap_flag_fault = 0;
05177                                         continue;
05178                                 }
05179                         if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
05180                                 if (soap_inliteral(soap, "-any", &a->__any))
05181                                 {       soap_flag___any--;
05182                                         continue;
05183                                 }
05184                         if (soap->error == SOAP_TAG_MISMATCH)
05185                                 soap->error = soap_ignore_element(soap);
05186                         if (soap->error == SOAP_NO_TAG)
05187                                 break;
05188                         if (soap->error)
05189                                 return NULL;
05190                 }
05191                 if (soap_element_end_in(soap, tag))
05192                         return NULL;
05193         }
05194         else
05195         {       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);
05196                 if (soap->body && soap_element_end_in(soap, tag))
05197                         return NULL;
05198         }
05199         return a;
05200 }
05201 
05202 SOAP_FMAC5 struct SOAP_ENV__Detail * SOAP_FMAC6 soap_new_SOAP_ENV__Detail(struct soap *soap, int n)
05203 {       return soap_instantiate_SOAP_ENV__Detail(soap, n, NULL, NULL, NULL);
05204 }
05205 
05206 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *p)
05207 {       soap_delete(soap, p);
05208 }
05209 
05210 SOAP_FMAC3 struct SOAP_ENV__Detail * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Detail(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
05211 {
05212         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Detail(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
05213         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Detail, n, soap_fdelete);
05214         if (!cp)
05215                 return NULL;
05216         if (n < 0)
05217         {       cp->ptr = (void*)new struct SOAP_ENV__Detail;
05218                 if (size)
05219                         *size = sizeof(struct SOAP_ENV__Detail);
05220         }
05221         else
05222         {       cp->ptr = (void*)new struct SOAP_ENV__Detail[n];
05223                 if (size)
05224                         *size = n * sizeof(struct SOAP_ENV__Detail);
05225         }
05226                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05227         return (struct SOAP_ENV__Detail*)cp->ptr;
05228 }
05229 
05230 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Detail(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05231 {
05232         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Detail %p -> %p\n", q, p));
05233         *(struct SOAP_ENV__Detail*)p = *(struct SOAP_ENV__Detail*)q;
05234 }
05235 
05236 #endif
05237 
05238 #ifndef WITH_NOGLOBAL
05239 
05240 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
05241 {
05242         (void)soap; (void)a; /* appease -Wall -Werror */
05243         soap_serialize__QName(soap, &a->SOAP_ENV__Value);
05244         soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
05245 }
05246 
05247 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
05248 {
05249         (void)soap; (void)a; /* appease -Wall -Werror */
05250         soap_default__QName(soap, &a->SOAP_ENV__Value);
05251         a->SOAP_ENV__Subcode = NULL;
05252 }
05253 
05254 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)
05255 {
05256         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Code);
05257         if (soap_out_SOAP_ENV__Code(soap, tag, id, a, type))
05258                 return soap->error;
05259         return soap_putindependent(soap);
05260 }
05261 
05262 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)
05263 {
05264         const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
05265         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Code), type);
05266         soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, "");
05267         soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, "");
05268         soap_element_end_out(soap, tag);
05269         return SOAP_OK;
05270 }
05271 
05272 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)
05273 {
05274         if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
05275                 soap_getindependent(soap);
05276         return p;
05277 }
05278 
05279 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)
05280 {
05281         short soap_flag_SOAP_ENV__Value = 1, soap_flag_SOAP_ENV__Subcode = 1;
05282         if (soap_element_begin_in(soap, tag, 0, type))
05283                 return NULL;
05284         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);
05285         if (!a)
05286                 return NULL;
05287         soap_default_SOAP_ENV__Code(soap, a);
05288         if (soap->body && !*soap->href)
05289         {
05290                 for (;;)
05291                 {       soap->error = SOAP_TAG_MISMATCH;
05292                         if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
05293                                 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
05294                                 {       soap_flag_SOAP_ENV__Value--;
05295                                         continue;
05296                                 }
05297                         if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
05298                                 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
05299                                 {       soap_flag_SOAP_ENV__Subcode--;
05300                                         continue;
05301                                 }
05302                         if (soap->error == SOAP_TAG_MISMATCH)
05303                                 soap->error = soap_ignore_element(soap);
05304                         if (soap->error == SOAP_NO_TAG)
05305                                 break;
05306                         if (soap->error)
05307                                 return NULL;
05308                 }
05309                 if (soap_element_end_in(soap, tag))
05310                         return NULL;
05311         }
05312         else
05313         {       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);
05314                 if (soap->body && soap_element_end_in(soap, tag))
05315                         return NULL;
05316         }
05317         return a;
05318 }
05319 
05320 SOAP_FMAC5 struct SOAP_ENV__Code * SOAP_FMAC6 soap_new_SOAP_ENV__Code(struct soap *soap, int n)
05321 {       return soap_instantiate_SOAP_ENV__Code(soap, n, NULL, NULL, NULL);
05322 }
05323 
05324 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *p)
05325 {       soap_delete(soap, p);
05326 }
05327 
05328 SOAP_FMAC3 struct SOAP_ENV__Code * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Code(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
05329 {
05330         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Code(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
05331         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Code, n, soap_fdelete);
05332         if (!cp)
05333                 return NULL;
05334         if (n < 0)
05335         {       cp->ptr = (void*)new struct SOAP_ENV__Code;
05336                 if (size)
05337                         *size = sizeof(struct SOAP_ENV__Code);
05338         }
05339         else
05340         {       cp->ptr = (void*)new struct SOAP_ENV__Code[n];
05341                 if (size)
05342                         *size = n * sizeof(struct SOAP_ENV__Code);
05343         }
05344                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05345         return (struct SOAP_ENV__Code*)cp->ptr;
05346 }
05347 
05348 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Code(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05349 {
05350         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Code %p -> %p\n", q, p));
05351         *(struct SOAP_ENV__Code*)p = *(struct SOAP_ENV__Code*)q;
05352 }
05353 
05354 #endif
05355 
05356 #ifndef WITH_NOGLOBAL
05357 
05358 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
05359 {
05360         (void)soap; (void)a; /* appease -Wall -Werror */
05361         /* transient dummy skipped */
05362 }
05363 
05364 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
05365 {
05366         (void)soap; (void)a; /* appease -Wall -Werror */
05367         /* transient dummy skipped */
05368 }
05369 
05370 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)
05371 {
05372         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_SOAP_ENV__Header);
05373         if (soap_out_SOAP_ENV__Header(soap, tag, id, a, type))
05374                 return soap->error;
05375         return soap_putindependent(soap);
05376 }
05377 
05378 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)
05379 {
05380         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_SOAP_ENV__Header), type);
05381         /* transient dummy skipped */
05382         soap_element_end_out(soap, tag);
05383         return SOAP_OK;
05384 }
05385 
05386 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)
05387 {
05388         if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
05389                 soap_getindependent(soap);
05390         return p;
05391 }
05392 
05393 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)
05394 {;
05395         if (soap_element_begin_in(soap, tag, 0, type))
05396                 return NULL;
05397         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);
05398         if (!a)
05399                 return NULL;
05400         soap_default_SOAP_ENV__Header(soap, a);
05401         if (soap->body && !*soap->href)
05402         {
05403                 for (;;)
05404                 {       soap->error = SOAP_TAG_MISMATCH;
05405                 /* transient dummy skipped */
05406                         if (soap->error == SOAP_TAG_MISMATCH)
05407                                 soap->error = soap_ignore_element(soap);
05408                         if (soap->error == SOAP_NO_TAG)
05409                                 break;
05410                         if (soap->error)
05411                                 return NULL;
05412                 }
05413                 if (soap_element_end_in(soap, tag))
05414                         return NULL;
05415         }
05416         else
05417         {       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);
05418                 if (soap->body && soap_element_end_in(soap, tag))
05419                         return NULL;
05420         }
05421         return a;
05422 }
05423 
05424 SOAP_FMAC5 struct SOAP_ENV__Header * SOAP_FMAC6 soap_new_SOAP_ENV__Header(struct soap *soap, int n)
05425 {       return soap_instantiate_SOAP_ENV__Header(soap, n, NULL, NULL, NULL);
05426 }
05427 
05428 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *p)
05429 {       soap_delete(soap, p);
05430 }
05431 
05432 SOAP_FMAC3 struct SOAP_ENV__Header * SOAP_FMAC4 soap_instantiate_SOAP_ENV__Header(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
05433 {
05434         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Header(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
05435         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_SOAP_ENV__Header, n, soap_fdelete);
05436         if (!cp)
05437                 return NULL;
05438         if (n < 0)
05439         {       cp->ptr = (void*)new struct SOAP_ENV__Header;
05440                 if (size)
05441                         *size = sizeof(struct SOAP_ENV__Header);
05442         }
05443         else
05444         {       cp->ptr = (void*)new struct SOAP_ENV__Header[n];
05445                 if (size)
05446                         *size = n * sizeof(struct SOAP_ENV__Header);
05447         }
05448                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05449         return (struct SOAP_ENV__Header*)cp->ptr;
05450 }
05451 
05452 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_SOAP_ENV__Header(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05453 {
05454         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Header %p -> %p\n", q, p));
05455         *(struct SOAP_ENV__Header*)p = *(struct SOAP_ENV__Header*)q;
05456 }
05457 
05458 #endif
05459 
05460 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_VRangeData(struct soap *soap, struct VRangeData const*a)
05461 {
05462         int i;
05463         if (a->__ptr && !soap_array_reference(soap, a, (struct soap_array*)&a->__ptr, 1, SOAP_TYPE_VRangeData))
05464                 for (i = 0; i < a->__size; i++)
05465                 {       soap_embedded(soap, a->__ptr + i, SOAP_TYPE_VRange);
05466                         soap_serialize_VRange(soap, a->__ptr + i);
05467                 }
05468 }
05469 
05470 SOAP_FMAC3 void SOAP_FMAC4 soap_default_VRangeData(struct soap *soap, struct VRangeData *a)
05471 {
05472         a->__size = 0;
05473         a->__ptr = NULL;
05474 }
05475 
05476 SOAP_FMAC3 int SOAP_FMAC4 soap_put_VRangeData(struct soap *soap, const struct VRangeData *a, const char *tag, const char *type)
05477 {
05478         register int id = soap_embed(soap, (void*)a, (struct soap_array*)&a->__ptr, 1, tag, SOAP_TYPE_VRangeData);
05479         if (soap_out_VRangeData(soap, tag, id, a, type))
05480                 return soap->error;
05481         return soap_putindependent(soap);
05482 }
05483 
05484 SOAP_FMAC3 int SOAP_FMAC4 soap_out_VRangeData(struct soap *soap, const char *tag, int id, const struct VRangeData *a, const char *type)
05485 {
05486         int i, n = a->__size;
05487         char *t = soap_putsize(soap, "VRange", a->__size);
05488         id = soap_element_id(soap, tag, id, a, (struct soap_array*)&a->__ptr, 1, type, SOAP_TYPE_VRangeData);
05489         if (id < 0)
05490                 return soap->error;
05491         soap_array_begin_out(soap, tag, id, t, NULL);
05492         for (i = 0; i < n; i++)
05493         {
05494                 soap->position = 1;
05495                 soap->positions[0] = i;
05496                 soap_out_VRange(soap, "item", -1, &a->__ptr[i], "VRange");
05497         }
05498         soap->position = 0;
05499         soap_element_end_out(soap, tag);
05500         return SOAP_OK;
05501 }
05502 
05503 SOAP_FMAC3 struct VRangeData * SOAP_FMAC4 soap_get_VRangeData(struct soap *soap, struct VRangeData *p, const char *tag, const char *type)
05504 {
05505         if ((p = soap_in_VRangeData(soap, tag, p, type)))
05506                 soap_getindependent(soap);
05507         return p;
05508 }
05509 
05510 SOAP_FMAC3 struct VRangeData * SOAP_FMAC4 soap_in_VRangeData(struct soap *soap, const char *tag, struct VRangeData *a, const char *type)
05511 {       int i, j;
05512         struct VRange *p;
05513         if (soap_element_begin_in(soap, tag, 1, NULL))
05514                 return NULL;
05515         if (soap_match_array(soap, type))
05516         {       soap->error = SOAP_TYPE;
05517                 return NULL;
05518         }
05519         a = (struct VRangeData *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_VRangeData, sizeof(struct VRangeData), 0, NULL, NULL, NULL);
05520         if (!a)
05521                 return NULL;
05522         soap_default_VRangeData(soap, a);
05523         if (soap->body && !*soap->href)
05524         {
05525                 a->__size = soap_getsize(soap->arraySize, soap->arrayOffset, &j);
05526                 if (a->__size >= 0)
05527                 {       a->__ptr = (struct VRange *)soap_malloc(soap, sizeof(struct VRange) * a->__size);
05528                         for (i = 0; i < a->__size; i++)
05529                                 soap_default_VRange(soap, a->__ptr+i);
05530                         for (i = 0; i < a->__size; i++)
05531                         {       soap_peek_element(soap);
05532                                 if (soap->position)
05533                                 {       i = soap->positions[0]-j;
05534                                         if (i < 0 || i >= a->__size)
05535                                         {       soap->error = SOAP_IOB;
05536                                                 return NULL;
05537                                         }
05538                                 }
05539                                 if (!soap_in_VRange(soap, NULL, a->__ptr + i, "VRange"))
05540                                 {       if (soap->error != SOAP_NO_TAG)
05541                                                 return NULL;
05542                                         soap->error = SOAP_OK;
05543                                         break;
05544                                 }
05545                         }
05546                 }
05547                 else
05548                 {       soap_new_block(soap);
05549                         for (a->__size = 0; ; a->__size++)
05550                         {       p = (struct VRange *)soap_push_block(soap, sizeof(struct VRange));
05551                                 if (!p)
05552                                         return NULL;
05553                                 soap_default_VRange(soap, p);
05554                                 if (!soap_in_VRange(soap, NULL, p, "VRange"))
05555                                 {       if (soap->error != SOAP_NO_TAG)
05556                                                 return NULL;
05557                                         soap->error = SOAP_OK;
05558                                         break;
05559                                 }
05560                         }
05561                         soap_pop_block(soap);
05562                         a->__ptr = (struct VRange *)soap_malloc(soap, soap->blist->size);
05563                         soap_save_block(soap, (char*)a->__ptr, 1);
05564                 }
05565                 if (soap_element_end_in(soap, tag))
05566                         return NULL;
05567         }
05568         else
05569         {       a = (struct VRangeData *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_VRangeData, 0, sizeof(struct VRangeData), 0, NULL);
05570                 if (soap->body && soap_element_end_in(soap, tag))
05571                         return NULL;
05572         }
05573         return a;
05574 }
05575 
05576 SOAP_FMAC5 struct VRangeData * SOAP_FMAC6 soap_new_VRangeData(struct soap *soap, int n)
05577 {       return soap_instantiate_VRangeData(soap, n, NULL, NULL, NULL);
05578 }
05579 
05580 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_VRangeData(struct soap *soap, struct VRangeData *p)
05581 {       soap_delete(soap, p);
05582 }
05583 
05584 SOAP_FMAC3 struct VRangeData * SOAP_FMAC4 soap_instantiate_VRangeData(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
05585 {
05586         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_VRangeData(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
05587         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_VRangeData, n, soap_fdelete);
05588         if (!cp)
05589                 return NULL;
05590         if (n < 0)
05591         {       cp->ptr = (void*)new struct VRangeData;
05592                 if (size)
05593                         *size = sizeof(struct VRangeData);
05594         }
05595         else
05596         {       cp->ptr = (void*)new struct VRangeData[n];
05597                 if (size)
05598                         *size = n * sizeof(struct VRangeData);
05599         }
05600                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05601         return (struct VRangeData*)cp->ptr;
05602 }
05603 
05604 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_VRangeData(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05605 {
05606         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct VRangeData %p -> %p\n", q, p));
05607         *(struct VRangeData*)p = *(struct VRangeData*)q;
05608 }
05609 
05610 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_VRange(struct soap *soap, const struct VRange *a)
05611 {
05612         (void)soap; (void)a; /* appease -Wall -Werror */
05613 }
05614 
05615 SOAP_FMAC3 void SOAP_FMAC4 soap_default_VRange(struct soap *soap, struct VRange *a)
05616 {
05617         (void)soap; (void)a; /* appease -Wall -Werror */
05618         soap_default_float(soap, &a->min);
05619         soap_default_float(soap, &a->max);
05620 }
05621 
05622 SOAP_FMAC3 int SOAP_FMAC4 soap_put_VRange(struct soap *soap, const struct VRange *a, const char *tag, const char *type)
05623 {
05624         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_VRange);
05625         if (soap_out_VRange(soap, tag, id, a, type))
05626                 return soap->error;
05627         return soap_putindependent(soap);
05628 }
05629 
05630 SOAP_FMAC3 int SOAP_FMAC4 soap_out_VRange(struct soap *soap, const char *tag, int id, const struct VRange *a, const char *type)
05631 {
05632         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_VRange), type);
05633         soap_out_float(soap, "min", -1, &a->min, "xsd:float");
05634         soap_out_float(soap, "max", -1, &a->max, "xsd:float");
05635         soap_element_end_out(soap, tag);
05636         return SOAP_OK;
05637 }
05638 
05639 SOAP_FMAC3 struct VRange * SOAP_FMAC4 soap_get_VRange(struct soap *soap, struct VRange *p, const char *tag, const char *type)
05640 {
05641         if ((p = soap_in_VRange(soap, tag, p, type)))
05642                 soap_getindependent(soap);
05643         return p;
05644 }
05645 
05646 SOAP_FMAC3 struct VRange * SOAP_FMAC4 soap_in_VRange(struct soap *soap, const char *tag, struct VRange *a, const char *type)
05647 {
05648         short soap_flag_min = 1, soap_flag_max = 1;
05649         if (soap_element_begin_in(soap, tag, 0, type))
05650                 return NULL;
05651         a = (struct VRange *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_VRange, sizeof(struct VRange), 0, NULL, NULL, NULL);
05652         if (!a)
05653                 return NULL;
05654         soap_default_VRange(soap, a);
05655         if (soap->body && !*soap->href)
05656         {
05657                 for (;;)
05658                 {       soap->error = SOAP_TAG_MISMATCH;
05659                         if (soap_flag_min && soap->error == SOAP_TAG_MISMATCH)
05660                                 if (soap_in_float(soap, "min", &a->min, "xsd:float"))
05661                                 {       soap_flag_min--;
05662                                         continue;
05663                                 }
05664                         if (soap_flag_max && soap->error == SOAP_TAG_MISMATCH)
05665                                 if (soap_in_float(soap, "max", &a->max, "xsd:float"))
05666                                 {       soap_flag_max--;
05667                                         continue;
05668                                 }
05669                         if (soap->error == SOAP_TAG_MISMATCH)
05670                                 soap->error = soap_ignore_element(soap);
05671                         if (soap->error == SOAP_NO_TAG)
05672                                 break;
05673                         if (soap->error)
05674                                 return NULL;
05675                 }
05676                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_min > 0 || soap_flag_max > 0))
05677                 {       soap->error = SOAP_OCCURS;
05678                         return NULL;
05679                 }
05680                 if (soap_element_end_in(soap, tag))
05681                         return NULL;
05682         }
05683         else
05684         {       a = (struct VRange *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_VRange, 0, sizeof(struct VRange), 0, NULL);
05685                 if (soap->body && soap_element_end_in(soap, tag))
05686                         return NULL;
05687         }
05688         return a;
05689 }
05690 
05691 SOAP_FMAC5 struct VRange * SOAP_FMAC6 soap_new_VRange(struct soap *soap, int n)
05692 {       return soap_instantiate_VRange(soap, n, NULL, NULL, NULL);
05693 }
05694 
05695 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_VRange(struct soap *soap, struct VRange *p)
05696 {       soap_delete(soap, p);
05697 }
05698 
05699 SOAP_FMAC3 struct VRange * SOAP_FMAC4 soap_instantiate_VRange(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
05700 {
05701         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_VRange(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
05702         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_VRange, n, soap_fdelete);
05703         if (!cp)
05704                 return NULL;
05705         if (n < 0)
05706         {       cp->ptr = (void*)new struct VRange;
05707                 if (size)
05708                         *size = sizeof(struct VRange);
05709         }
05710         else
05711         {       cp->ptr = (void*)new struct VRange[n];
05712                 if (size)
05713                         *size = n * sizeof(struct VRange);
05714         }
05715                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05716         return (struct VRange*)cp->ptr;
05717 }
05718 
05719 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_VRange(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05720 {
05721         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct VRange %p -> %p\n", q, p));
05722         *(struct VRange*)p = *(struct VRange*)q;
05723 }
05724 
05725 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_acq2xx__Signal(struct soap *soap, const struct acq2xx__Signal *a)
05726 {
05727         (void)soap; (void)a; /* appease -Wall -Werror */
05728 }
05729 
05730 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__Signal(struct soap *soap, struct acq2xx__Signal *a)
05731 {
05732         (void)soap; (void)a; /* appease -Wall -Werror */
05733         soap_default_acq2xx__DIx(soap, &a->dix);
05734         soap_default_acq2xx__EDGE(soap, &a->edge);
05735 }
05736 
05737 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__Signal(struct soap *soap, const struct acq2xx__Signal *a, const char *tag, const char *type)
05738 {
05739         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__Signal);
05740         if (soap_out_acq2xx__Signal(soap, tag, id, a, type))
05741                 return soap->error;
05742         return soap_putindependent(soap);
05743 }
05744 
05745 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__Signal(struct soap *soap, const char *tag, int id, const struct acq2xx__Signal *a, const char *type)
05746 {
05747         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__Signal), type);
05748         soap_out_acq2xx__DIx(soap, "acq2xx:dix", -1, &a->dix, "acq2xx:DIx");
05749         soap_out_acq2xx__EDGE(soap, "acq2xx:edge", -1, &a->edge, "acq2xx:EDGE");
05750         soap_element_end_out(soap, tag);
05751         return SOAP_OK;
05752 }
05753 
05754 SOAP_FMAC3 struct acq2xx__Signal * SOAP_FMAC4 soap_get_acq2xx__Signal(struct soap *soap, struct acq2xx__Signal *p, const char *tag, const char *type)
05755 {
05756         if ((p = soap_in_acq2xx__Signal(soap, tag, p, type)))
05757                 soap_getindependent(soap);
05758         return p;
05759 }
05760 
05761 SOAP_FMAC3 struct acq2xx__Signal * SOAP_FMAC4 soap_in_acq2xx__Signal(struct soap *soap, const char *tag, struct acq2xx__Signal *a, const char *type)
05762 {
05763         short soap_flag_dix = 1, soap_flag_edge = 1;
05764         if (soap_element_begin_in(soap, tag, 0, type))
05765                 return NULL;
05766         a = (struct acq2xx__Signal *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__Signal, sizeof(struct acq2xx__Signal), 0, NULL, NULL, NULL);
05767         if (!a)
05768                 return NULL;
05769         soap_default_acq2xx__Signal(soap, a);
05770         if (soap->body && !*soap->href)
05771         {
05772                 for (;;)
05773                 {       soap->error = SOAP_TAG_MISMATCH;
05774                         if (soap_flag_dix && soap->error == SOAP_TAG_MISMATCH)
05775                                 if (soap_in_acq2xx__DIx(soap, "acq2xx:dix", &a->dix, "acq2xx:DIx"))
05776                                 {       soap_flag_dix--;
05777                                         continue;
05778                                 }
05779                         if (soap_flag_edge && soap->error == SOAP_TAG_MISMATCH)
05780                                 if (soap_in_acq2xx__EDGE(soap, "acq2xx:edge", &a->edge, "acq2xx:EDGE"))
05781                                 {       soap_flag_edge--;
05782                                         continue;
05783                                 }
05784                         if (soap->error == SOAP_TAG_MISMATCH)
05785                                 soap->error = soap_ignore_element(soap);
05786                         if (soap->error == SOAP_NO_TAG)
05787                                 break;
05788                         if (soap->error)
05789                                 return NULL;
05790                 }
05791                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_dix > 0 || soap_flag_edge > 0))
05792                 {       soap->error = SOAP_OCCURS;
05793                         return NULL;
05794                 }
05795                 if (soap_element_end_in(soap, tag))
05796                         return NULL;
05797         }
05798         else
05799         {       a = (struct acq2xx__Signal *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__Signal, 0, sizeof(struct acq2xx__Signal), 0, NULL);
05800                 if (soap->body && soap_element_end_in(soap, tag))
05801                         return NULL;
05802         }
05803         return a;
05804 }
05805 
05806 SOAP_FMAC5 struct acq2xx__Signal * SOAP_FMAC6 soap_new_acq2xx__Signal(struct soap *soap, int n)
05807 {       return soap_instantiate_acq2xx__Signal(soap, n, NULL, NULL, NULL);
05808 }
05809 
05810 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__Signal(struct soap *soap, struct acq2xx__Signal *p)
05811 {       soap_delete(soap, p);
05812 }
05813 
05814 SOAP_FMAC3 struct acq2xx__Signal * SOAP_FMAC4 soap_instantiate_acq2xx__Signal(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
05815 {
05816         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__Signal(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
05817         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__Signal, n, soap_fdelete);
05818         if (!cp)
05819                 return NULL;
05820         if (n < 0)
05821         {       cp->ptr = (void*)new struct acq2xx__Signal;
05822                 if (size)
05823                         *size = sizeof(struct acq2xx__Signal);
05824         }
05825         else
05826         {       cp->ptr = (void*)new struct acq2xx__Signal[n];
05827                 if (size)
05828                         *size = n * sizeof(struct acq2xx__Signal);
05829         }
05830                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05831         return (struct acq2xx__Signal*)cp->ptr;
05832 }
05833 
05834 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__Signal(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05835 {
05836         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct acq2xx__Signal %p -> %p\n", q, p));
05837         *(struct acq2xx__Signal*)p = *(struct acq2xx__Signal*)q;
05838 }
05839 
05840 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_acq2xx__waitStop(struct soap *soap, const struct acq2xx__waitStop *a)
05841 {
05842         (void)soap; (void)a; /* appease -Wall -Werror */
05843 }
05844 
05845 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__waitStop(struct soap *soap, struct acq2xx__waitStop *a)
05846 {
05847         (void)soap; (void)a; /* appease -Wall -Werror */
05848         soap_default_int(soap, &a->timeout_sec);
05849 }
05850 
05851 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__waitStop(struct soap *soap, const struct acq2xx__waitStop *a, const char *tag, const char *type)
05852 {
05853         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__waitStop);
05854         if (soap_out_acq2xx__waitStop(soap, tag, id, a, type))
05855                 return soap->error;
05856         return soap_putindependent(soap);
05857 }
05858 
05859 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__waitStop(struct soap *soap, const char *tag, int id, const struct acq2xx__waitStop *a, const char *type)
05860 {
05861         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__waitStop), type);
05862         soap_out_int(soap, "acq2xx:timeout-sec", -1, &a->timeout_sec, "xsd:int");
05863         soap_element_end_out(soap, tag);
05864         return SOAP_OK;
05865 }
05866 
05867 SOAP_FMAC3 struct acq2xx__waitStop * SOAP_FMAC4 soap_get_acq2xx__waitStop(struct soap *soap, struct acq2xx__waitStop *p, const char *tag, const char *type)
05868 {
05869         if ((p = soap_in_acq2xx__waitStop(soap, tag, p, type)))
05870                 soap_getindependent(soap);
05871         return p;
05872 }
05873 
05874 SOAP_FMAC3 struct acq2xx__waitStop * SOAP_FMAC4 soap_in_acq2xx__waitStop(struct soap *soap, const char *tag, struct acq2xx__waitStop *a, const char *type)
05875 {
05876         short soap_flag_timeout_sec = 1;
05877         if (soap_element_begin_in(soap, tag, 0, type))
05878                 return NULL;
05879         a = (struct acq2xx__waitStop *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__waitStop, sizeof(struct acq2xx__waitStop), 0, NULL, NULL, NULL);
05880         if (!a)
05881                 return NULL;
05882         soap_default_acq2xx__waitStop(soap, a);
05883         if (soap->body && !*soap->href)
05884         {
05885                 for (;;)
05886                 {       soap->error = SOAP_TAG_MISMATCH;
05887                         if (soap_flag_timeout_sec && soap->error == SOAP_TAG_MISMATCH)
05888                                 if (soap_in_int(soap, "acq2xx:timeout-sec", &a->timeout_sec, "xsd:int"))
05889                                 {       soap_flag_timeout_sec--;
05890                                         continue;
05891                                 }
05892                         if (soap->error == SOAP_TAG_MISMATCH)
05893                                 soap->error = soap_ignore_element(soap);
05894                         if (soap->error == SOAP_NO_TAG)
05895                                 break;
05896                         if (soap->error)
05897                                 return NULL;
05898                 }
05899                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_timeout_sec > 0))
05900                 {       soap->error = SOAP_OCCURS;
05901                         return NULL;
05902                 }
05903                 if (soap_element_end_in(soap, tag))
05904                         return NULL;
05905         }
05906         else
05907         {       a = (struct acq2xx__waitStop *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__waitStop, 0, sizeof(struct acq2xx__waitStop), 0, NULL);
05908                 if (soap->body && soap_element_end_in(soap, tag))
05909                         return NULL;
05910         }
05911         return a;
05912 }
05913 
05914 SOAP_FMAC5 struct acq2xx__waitStop * SOAP_FMAC6 soap_new_acq2xx__waitStop(struct soap *soap, int n)
05915 {       return soap_instantiate_acq2xx__waitStop(soap, n, NULL, NULL, NULL);
05916 }
05917 
05918 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__waitStop(struct soap *soap, struct acq2xx__waitStop *p)
05919 {       soap_delete(soap, p);
05920 }
05921 
05922 SOAP_FMAC3 struct acq2xx__waitStop * SOAP_FMAC4 soap_instantiate_acq2xx__waitStop(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
05923 {
05924         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__waitStop(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
05925         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__waitStop, n, soap_fdelete);
05926         if (!cp)
05927                 return NULL;
05928         if (n < 0)
05929         {       cp->ptr = (void*)new struct acq2xx__waitStop;
05930                 if (size)
05931                         *size = sizeof(struct acq2xx__waitStop);
05932         }
05933         else
05934         {       cp->ptr = (void*)new struct acq2xx__waitStop[n];
05935                 if (size)
05936                         *size = n * sizeof(struct acq2xx__waitStop);
05937         }
05938                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
05939         return (struct acq2xx__waitStop*)cp->ptr;
05940 }
05941 
05942 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__waitStop(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
05943 {
05944         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct acq2xx__waitStop %p -> %p\n", q, p));
05945         *(struct acq2xx__waitStop*)p = *(struct acq2xx__waitStop*)q;
05946 }
05947 
05948 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_acq2xx__setArm(struct soap *soap, const struct acq2xx__setArm *a)
05949 {
05950         (void)soap; (void)a; /* appease -Wall -Werror */
05951 }
05952 
05953 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__setArm(struct soap *soap, struct acq2xx__setArm *a)
05954 {
05955         (void)soap; (void)a; /* appease -Wall -Werror */
05956         a->block = 0;
05957 }
05958 
05959 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__setArm(struct soap *soap, const struct acq2xx__setArm *a, const char *tag, const char *type)
05960 {
05961         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__setArm);
05962         if (soap_out_acq2xx__setArm(soap, tag, id, a, type))
05963                 return soap->error;
05964         return soap_putindependent(soap);
05965 }
05966 
05967 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__setArm(struct soap *soap, const char *tag, int id, const struct acq2xx__setArm *a, const char *type)
05968 {
05969         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__setArm), type);
05970         soap_out_int(soap, "acq2xx:block", -1, &a->block, "xsd:int");
05971         soap_element_end_out(soap, tag);
05972         return SOAP_OK;
05973 }
05974 
05975 SOAP_FMAC3 struct acq2xx__setArm * SOAP_FMAC4 soap_get_acq2xx__setArm(struct soap *soap, struct acq2xx__setArm *p, const char *tag, const char *type)
05976 {
05977         if ((p = soap_in_acq2xx__setArm(soap, tag, p, type)))
05978                 soap_getindependent(soap);
05979         return p;
05980 }
05981 
05982 SOAP_FMAC3 struct acq2xx__setArm * SOAP_FMAC4 soap_in_acq2xx__setArm(struct soap *soap, const char *tag, struct acq2xx__setArm *a, const char *type)
05983 {
05984         short soap_flag_block = 1;
05985         if (soap_element_begin_in(soap, tag, 0, type))
05986                 return NULL;
05987         a = (struct acq2xx__setArm *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__setArm, sizeof(struct acq2xx__setArm), 0, NULL, NULL, NULL);
05988         if (!a)
05989                 return NULL;
05990         soap_default_acq2xx__setArm(soap, a);
05991         if (soap->body && !*soap->href)
05992         {
05993                 for (;;)
05994                 {       soap->error = SOAP_TAG_MISMATCH;
05995                         if (soap_flag_block && soap->error == SOAP_TAG_MISMATCH)
05996                                 if (soap_in_int(soap, "acq2xx:block", &a->block, "xsd:int"))
05997                                 {       soap_flag_block--;
05998                                         continue;
05999                                 }
06000                         if (soap->error == SOAP_TAG_MISMATCH)
06001                                 soap->error = soap_ignore_element(soap);
06002                         if (soap->error == SOAP_NO_TAG)
06003                                 break;
06004                         if (soap->error)
06005                                 return NULL;
06006                 }
06007                 if (soap_element_end_in(soap, tag))
06008                         return NULL;
06009         }
06010         else
06011         {       a = (struct acq2xx__setArm *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__setArm, 0, sizeof(struct acq2xx__setArm), 0, NULL);
06012                 if (soap->body && soap_element_end_in(soap, tag))
06013                         return NULL;
06014         }
06015         return a;
06016 }
06017 
06018 SOAP_FMAC5 struct acq2xx__setArm * SOAP_FMAC6 soap_new_acq2xx__setArm(struct soap *soap, int n)
06019 {       return soap_instantiate_acq2xx__setArm(soap, n, NULL, NULL, NULL);
06020 }
06021 
06022 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__setArm(struct soap *soap, struct acq2xx__setArm *p)
06023 {       soap_delete(soap, p);
06024 }
06025 
06026 SOAP_FMAC3 struct acq2xx__setArm * SOAP_FMAC4 soap_instantiate_acq2xx__setArm(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
06027 {
06028         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__setArm(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
06029         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__setArm, n, soap_fdelete);
06030         if (!cp)
06031                 return NULL;
06032         if (n < 0)
06033         {       cp->ptr = (void*)new struct acq2xx__setArm;
06034                 if (size)
06035                         *size = sizeof(struct acq2xx__setArm);
06036         }
06037         else
06038         {       cp->ptr = (void*)new struct acq2xx__setArm[n];
06039                 if (size)
06040                         *size = n * sizeof(struct acq2xx__setArm);
06041         }
06042                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
06043         return (struct acq2xx__setArm*)cp->ptr;
06044 }
06045 
06046 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__setArm(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
06047 {
06048         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct acq2xx__setArm %p -> %p\n", q, p));
06049         *(struct acq2xx__setArm*)p = *(struct acq2xx__setArm*)q;
06050 }
06051 
06052 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_acq2xx__getAcqStatus(struct soap *soap, const struct acq2xx__getAcqStatus *a)
06053 {
06054         (void)soap; (void)a; /* appease -Wall -Werror */
06055 }
06056 
06057 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__getAcqStatus(struct soap *soap, struct acq2xx__getAcqStatus *a)
06058 {
06059         (void)soap; (void)a; /* appease -Wall -Werror */
06060 }
06061 
06062 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__getAcqStatus(struct soap *soap, const struct acq2xx__getAcqStatus *a, const char *tag, const char *type)
06063 {
06064         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__getAcqStatus);
06065         if (soap_out_acq2xx__getAcqStatus(soap, tag, id, a, type))
06066                 return soap->error;
06067         return soap_putindependent(soap);
06068 }
06069 
06070 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__getAcqStatus(struct soap *soap, const char *tag, int id, const struct acq2xx__getAcqStatus *a, const char *type)
06071 {
06072         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__getAcqStatus), type);
06073         soap_element_end_out(soap, tag);
06074         return SOAP_OK;
06075 }
06076 
06077 SOAP_FMAC3 struct acq2xx__getAcqStatus * SOAP_FMAC4 soap_get_acq2xx__getAcqStatus(struct soap *soap, struct acq2xx__getAcqStatus *p, const char *tag, const char *type)
06078 {
06079         if ((p = soap_in_acq2xx__getAcqStatus(soap, tag, p, type)))
06080                 soap_getindependent(soap);
06081         return p;
06082 }
06083 
06084 SOAP_FMAC3 struct acq2xx__getAcqStatus * SOAP_FMAC4 soap_in_acq2xx__getAcqStatus(struct soap *soap, const char *tag, struct acq2xx__getAcqStatus *a, const char *type)
06085 {;
06086         if (soap_element_begin_in(soap, tag, 0, type))
06087                 return NULL;
06088         a = (struct acq2xx__getAcqStatus *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__getAcqStatus, sizeof(struct acq2xx__getAcqStatus), 0, NULL, NULL, NULL);
06089         if (!a)
06090                 return NULL;
06091         soap_default_acq2xx__getAcqStatus(soap, a);
06092         if (soap->body && !*soap->href)
06093         {
06094                 for (;;)
06095                 {       soap->error = SOAP_TAG_MISMATCH;
06096                         if (soap->error == SOAP_TAG_MISMATCH)
06097                                 soap->error = soap_ignore_element(soap);
06098                         if (soap->error == SOAP_NO_TAG)
06099                                 break;
06100                         if (soap->error)
06101                                 return NULL;
06102                 }
06103                 if (soap_element_end_in(soap, tag))
06104                         return NULL;
06105         }
06106         else
06107         {       a = (struct acq2xx__getAcqStatus *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__getAcqStatus, 0, sizeof(struct acq2xx__getAcqStatus), 0, NULL);
06108                 if (soap->body && soap_element_end_in(soap, tag))
06109                         return NULL;
06110         }
06111         return a;
06112 }
06113 
06114 SOAP_FMAC5 struct acq2xx__getAcqStatus * SOAP_FMAC6 soap_new_acq2xx__getAcqStatus(struct soap *soap, int n)
06115 {       return soap_instantiate_acq2xx__getAcqStatus(soap, n, NULL, NULL, NULL);
06116 }
06117 
06118 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__getAcqStatus(struct soap *soap, struct acq2xx__getAcqStatus *p)
06119 {       soap_delete(soap, p);
06120 }
06121 
06122 SOAP_FMAC3 struct acq2xx__getAcqStatus * SOAP_FMAC4 soap_instantiate_acq2xx__getAcqStatus(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
06123 {
06124         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__getAcqStatus(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
06125         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__getAcqStatus, n, soap_fdelete);
06126         if (!cp)
06127                 return NULL;
06128         if (n < 0)
06129         {       cp->ptr = (void*)new struct acq2xx__getAcqStatus;
06130                 if (size)
06131                         *size = sizeof(struct acq2xx__getAcqStatus);
06132         }
06133         else
06134         {       cp->ptr = (void*)new struct acq2xx__getAcqStatus[n];
06135                 if (size)
06136                         *size = n * sizeof(struct acq2xx__getAcqStatus);
06137         }
06138                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
06139         return (struct acq2xx__getAcqStatus*)cp->ptr;
06140 }
06141 
06142 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__getAcqStatus(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
06143 {
06144         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct acq2xx__getAcqStatus %p -> %p\n", q, p));
06145         *(struct acq2xx__getAcqStatus*)p = *(struct acq2xx__getAcqStatus*)q;
06146 }
06147 
06148 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_acq2xx__AcqStatus(struct soap *soap, const struct acq2xx__AcqStatus *a)
06149 {
06150         (void)soap; (void)a; /* appease -Wall -Werror */
06151         soap_serialize_string(soap, &a->state_string);
06152 }
06153 
06154 SOAP_FMAC3 void SOAP_FMAC4 soap_default_acq2xx__AcqStatus(struct soap *soap, struct acq2xx__AcqStatus *a)
06155 {
06156         (void)soap; (void)a; /* appease -Wall -Werror */
06157         soap_default_STATE(soap, &a->state);
06158         soap_default_string(soap, &a->state_string);
06159         soap_default_int(soap, &a->numsamples);
06160         soap_default_int(soap, &a->prelen);
06161         soap_default_int(soap, &a->postlen);
06162         soap_default_int(soap, &a->elapsed);
06163         soap_default_int(soap, &a->nchan);
06164 }
06165 
06166 SOAP_FMAC3 int SOAP_FMAC4 soap_put_acq2xx__AcqStatus(struct soap *soap, const struct acq2xx__AcqStatus *a, const char *tag, const char *type)
06167 {
06168         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_acq2xx__AcqStatus);
06169         if (soap_out_acq2xx__AcqStatus(soap, tag, id, a, type))
06170                 return soap->error;
06171         return soap_putindependent(soap);
06172 }
06173 
06174 SOAP_FMAC3 int SOAP_FMAC4 soap_out_acq2xx__AcqStatus(struct soap *soap, const char *tag, int id, const struct acq2xx__AcqStatus *a, const char *type)
06175 {
06176         soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_acq2xx__AcqStatus), type);
06177         soap_element_result(soap, "acq2xx:state");
06178         soap_out_STATE(soap, "acq2xx:state", -1, &a->state, "STATE");
06179         soap_out_string(soap, "acq2xx:state-string", -1, &a->state_string, "xsd:string");
06180         soap_out_int(soap, "acq2xx:numsamples", -1, &a->numsamples, "xsd:int");
06181         soap_out_int(soap, "acq2xx:prelen", -1, &a->prelen, "xsd:int");
06182         soap_out_int(soap, "acq2xx:postlen", -1, &a->postlen, "xsd:int");
06183         soap_out_int(soap, "acq2xx:elapsed", -1, &a->elapsed, "xsd:int");
06184         soap_out_int(soap, "acq2xx:nchan", -1, &a->nchan, "xsd:int");
06185         soap_element_end_out(soap, tag);
06186         return SOAP_OK;
06187 }
06188 
06189 SOAP_FMAC3 struct acq2xx__AcqStatus * SOAP_FMAC4 soap_get_acq2xx__AcqStatus(struct soap *soap, struct acq2xx__AcqStatus *p, const char *tag, const char *type)
06190 {
06191         if ((p = soap_in_acq2xx__AcqStatus(soap, tag, p, type)))
06192                 soap_getindependent(soap);
06193         return p;
06194 }
06195 
06196 SOAP_FMAC3 struct acq2xx__AcqStatus * SOAP_FMAC4 soap_in_acq2xx__AcqStatus(struct soap *soap, const char *tag, struct acq2xx__AcqStatus *a, const char *type)
06197 {
06198         short soap_flag_state = 1, soap_flag_state_string = 1, soap_flag_numsamples = 1, soap_flag_prelen = 1, soap_flag_postlen = 1, soap_flag_elapsed = 1, soap_flag_nchan = 1;
06199         if (soap_element_begin_in(soap, tag, 0, type))
06200                 return NULL;
06201         a = (struct acq2xx__AcqStatus *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_acq2xx__AcqStatus, sizeof(struct acq2xx__AcqStatus), 0, NULL, NULL, NULL);
06202         if (!a)
06203                 return NULL;
06204         soap_default_acq2xx__AcqStatus(soap, a);
06205         if (soap->body && !*soap->href)
06206         {
06207                 for (;;)
06208                 {       soap->error = SOAP_TAG_MISMATCH;
06209                         if (soap_flag_state && soap->error == SOAP_TAG_MISMATCH)
06210                                 if (soap_in_STATE(soap, "acq2xx:state", &a->state, "STATE"))
06211                                 {       soap_flag_state--;
06212                                         continue;
06213                                 }
06214                         if (soap_flag_state_string && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
06215                                 if (soap_in_string(soap, "acq2xx:state-string", &a->state_string, "xsd:string"))
06216                                 {       soap_flag_state_string--;
06217                                         continue;
06218                                 }
06219                         if (soap_flag_numsamples && soap->error == SOAP_TAG_MISMATCH)
06220                                 if (soap_in_int(soap, "acq2xx:numsamples", &a->numsamples, "xsd:int"))
06221                                 {       soap_flag_numsamples--;
06222                                         continue;
06223                                 }
06224                         if (soap_flag_prelen && soap->error == SOAP_TAG_MISMATCH)
06225                                 if (soap_in_int(soap, "acq2xx:prelen", &a->prelen, "xsd:int"))
06226                                 {       soap_flag_prelen--;
06227                                         continue;
06228                                 }
06229                         if (soap_flag_postlen && soap->error == SOAP_TAG_MISMATCH)
06230                                 if (soap_in_int(soap, "acq2xx:postlen", &a->postlen, "xsd:int"))
06231                                 {       soap_flag_postlen--;
06232                                         continue;
06233                                 }
06234                         if (soap_flag_elapsed && soap->error == SOAP_TAG_MISMATCH)
06235                                 if (soap_in_int(soap, "acq2xx:elapsed", &a->elapsed, "xsd:int"))
06236                                 {       soap_flag_elapsed--;
06237                                         continue;
06238                                 }
06239                         if (soap_flag_nchan && soap->error == SOAP_TAG_MISMATCH)
06240                                 if (soap_in_int(soap, "acq2xx:nchan", &a->nchan, "xsd:int"))
06241                                 {       soap_flag_nchan--;
06242                                         continue;
06243                                 }
06244                         soap_check_result(soap, "acq2xx:state");
06245                         if (soap->error == SOAP_TAG_MISMATCH)
06246                                 soap->error = soap_ignore_element(soap);
06247                         if (soap->error == SOAP_NO_TAG)
06248                                 break;
06249                         if (soap->error)
06250                                 return NULL;
06251                 }
06252                 if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_state > 0 || soap_flag_numsamples > 0 || soap_flag_prelen > 0 || soap_flag_postlen > 0 || soap_flag_elapsed > 0 || soap_flag_nchan > 0))
06253                 {       soap->error = SOAP_OCCURS;
06254                         return NULL;
06255                 }
06256                 if (soap_element_end_in(soap, tag))
06257                         return NULL;
06258         }
06259         else
06260         {       a = (struct acq2xx__AcqStatus *)soap_id_forward(soap, soap->href, (void**)a, 0, SOAP_TYPE_acq2xx__AcqStatus, 0, sizeof(struct acq2xx__AcqStatus), 0, NULL);
06261                 if (soap->body && soap_element_end_in(soap, tag))
06262                         return NULL;
06263         }
06264         return a;
06265 }
06266 
06267 SOAP_FMAC5 struct acq2xx__AcqStatus * SOAP_FMAC6 soap_new_acq2xx__AcqStatus(struct soap *soap, int n)
06268 {       return soap_instantiate_acq2xx__AcqStatus(soap, n, NULL, NULL, NULL);
06269 }
06270 
06271 SOAP_FMAC5 void SOAP_FMAC6 soap_delete_acq2xx__AcqStatus(struct soap *soap, struct acq2xx__AcqStatus *p)
06272 {       soap_delete(soap, p);
06273 }
06274 
06275 SOAP_FMAC3 struct acq2xx__AcqStatus * SOAP_FMAC4 soap_instantiate_acq2xx__AcqStatus(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
06276 {
06277         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_acq2xx__AcqStatus(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
06278         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_acq2xx__AcqStatus, n, soap_fdelete);
06279         if (!cp)
06280                 return NULL;
06281         if (n < 0)
06282         {       cp->ptr = (void*)new struct acq2xx__AcqStatus;
06283                 if (size)
06284                         *size = sizeof(struct acq2xx__AcqStatus);
06285         }
06286         else
06287         {       cp->ptr = (void*)new struct acq2xx__AcqStatus[n];
06288                 if (size)
06289                         *size = n * sizeof(struct acq2xx__AcqStatus);
06290         }
06291                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
06292         return (struct acq2xx__AcqStatus*)cp->ptr;
06293 }
06294 
06295 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_acq2xx__AcqStatus(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
06296 {
06297         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct acq2xx__AcqStatus %p -> %p\n", q, p));
06298         *(struct acq2xx__AcqStatus*)p = *(struct acq2xx__AcqStatus*)q;
06299 }
06300 
06301 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_acq2xx__acq2script(