usr/src/lib/libkmsagent/common/SOAP/KMS_CAC.cpp

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 /* KMS_CAC.cpp
  27    Generated by gSOAP 2.7.17 from ../gsoapStubs/CAService/KMS_CA_SOAP.h
  28    Copyright(C) 2000-2010, Robert van Engelen, Genivia Inc. All Rights Reserved.
  29    This part of the software is released under one of the following licenses:
  30    GPL, the gSOAP public license, or Genivia's license for commercial use.
  31 */
  32
  33 #if defined(__BORLANDC__)
  34 #pragma option push -w-8060
  35 #pragma option push -w-8004
  36 #endif
  37
  38 #include "KMS_CAH.h"
  39
  40 namespace KMS_CA {
  41
  42 SOAP_SOURCE_STAMP("@(#) KMS_CAC.cpp ver 2.7.17 2010-06-08 19:16:38 GMT")
  43
  44
  45 #ifndef WITH_NOGLOBAL
  46
  47 SOAP_FMAC3 void SOAP_FMAC4 soap_serializeheader(struct soap *soap)
  48 {
  49         if (soap->header)
  50                 soap_serialize_SOAP_ENV__Header(soap, soap->header);
  51 }
  52
  53 SOAP_FMAC3 int SOAP_FMAC4 soap_putheader(struct soap *soap)
  54 {
  55         if (soap->header)
  56         {       soap->part = SOAP_IN_HEADER;
  57                 if (soap_out_SOAP_ENV__Header(soap, "SOAP-ENV:Header", 0, soap->header, NULL))
  58                         return soap->error;
  59                 soap->part = SOAP_END_HEADER;
  60         }
  61         return SOAP_OK;
  62 }
  63
  64 SOAP_FMAC3 int SOAP_FMAC4 soap_getheader(struct soap *soap)
  65 {
  66         soap->part = SOAP_IN_HEADER;
  67         soap->header = soap_in_SOAP_ENV__Header(soap, "SOAP-ENV:Header", NULL, NULL);
  68         soap->part = SOAP_END_HEADER;
  69         return soap->header == NULL;
  70 }
  71
  72 SOAP_FMAC3 void SOAP_FMAC4 soap_header(struct soap *soap)
  73 {
  74         if (!soap->header)
  75         {       if ((soap->header = soap_new_SOAP_ENV__Header(soap, -1)))
  76                         soap_default_SOAP_ENV__Header(soap, soap->header);
  77         }
  78 }
  79
  80 SOAP_FMAC3 void SOAP_FMAC4 soap_fault(struct soap *soap)
  81 {
  82         if (!soap->fault)
  83         {       soap->fault = soap_new_SOAP_ENV__Fault(soap, -1);
  84                 if (!soap->fault)
  85                         return;
  86                 soap_default_SOAP_ENV__Fault(soap, soap->fault);
  87         }
  88         if (soap->version == 2 && !soap->fault->SOAP_ENV__Code)
  89         {       soap->fault->SOAP_ENV__Code = soap_new_SOAP_ENV__Code(soap, -1);
  90                 soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code);
  91         }
  92         if (soap->version == 2 && !soap->fault->SOAP_ENV__Reason)
  93         {       soap->fault->SOAP_ENV__Reason = soap_new_SOAP_ENV__Reason(soap, -1);
  94                 soap_default_SOAP_ENV__Reason(soap, soap->fault->SOAP_ENV__Reason);
  95         }
  96 }
  97
  98 SOAP_FMAC3 void SOAP_FMAC4 soap_serializefault(struct soap *soap)
  99 {
 100         soap_fault(soap);
 101         if (soap->fault)
 102                 soap_serialize_SOAP_ENV__Fault(soap, soap->fault);
 103 }
 104
 105 SOAP_FMAC3 int SOAP_FMAC4 soap_putfault(struct soap *soap)
 106 {
 107         if (soap->fault)
 108                 return soap_put_SOAP_ENV__Fault(soap, soap->fault, "SOAP-ENV:Fault", NULL);
 109         return SOAP_OK;
 110 }
 111
 112 SOAP_FMAC3 int SOAP_FMAC4 soap_getfault(struct soap *soap)
 113 {
 114         return (soap->fault = soap_get_SOAP_ENV__Fault(soap, NULL, "SOAP-ENV:Fault", NULL)) == NULL;
 115 }
 116
 117 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultcode(struct soap *soap)
 118 {
 119         soap_fault(soap);
 120         if (soap->version == 2)
 121                 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Value;
 122         return (const char**)&soap->fault->faultcode;
 123 }
 124
 125 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultsubcode(struct soap *soap)
 126 {
 127         soap_fault(soap);
 128         if (soap->version == 2)
 129         {       if (!soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode)
 130                 {       soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode = soap_new_SOAP_ENV__Code(soap, -1);
 131                         soap_default_SOAP_ENV__Code(soap, soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode);
 132                 }
 133                 return (const char**)&soap->fault->SOAP_ENV__Code->SOAP_ENV__Subcode->SOAP_ENV__Value;
 134         }
 135         return (const char**)&soap->fault->faultcode;
 136 }
 137
 138 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultstring(struct soap *soap)
 139 {
 140         soap_fault(soap);
 141         if (soap->version == 2)
 142                 return (const char**)&soap->fault->SOAP_ENV__Reason->SOAP_ENV__Text;
 143         return (const char**)&soap->fault->faultstring;
 144 }
 145
 146 SOAP_FMAC3 const char ** SOAP_FMAC4 soap_faultdetail(struct soap *soap)
 147 {
 148         soap_fault(soap);
 149         if (soap->version == 1)
 150         {       if (!soap->fault->detail)
 151                 {       soap->fault->detail = (struct SOAP_ENV__Detail*)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail));
 152                         soap_default_SOAP_ENV__Detail(soap, soap->fault->detail);
 153                 }
 154                 return (const char**)&soap->fault->detail->__any;
 155         }
 156         if (!soap->fault->SOAP_ENV__Detail)
 157         {       soap->fault->SOAP_ENV__Detail = soap_new_SOAP_ENV__Detail(soap, -1);
 158                 soap_default_SOAP_ENV__Detail(soap, soap->fault->SOAP_ENV__Detail);
 159         }
 160         return (const char**)&soap->fault->SOAP_ENV__Detail->__any;
 161 }
 162
 163 #endif
 164
 165 #ifndef WITH_NOIDREF
 166 SOAP_FMAC3 int SOAP_FMAC4 soap_getindependent(struct soap *soap)
 167 {
 168         int t;
 169         if (soap->version == 1)
 170         {       for (;;)
 171                 {       if (!soap_getelement(soap, &t))
 172                                 if (soap->error || soap_ignore_element(soap))
 173                                         break;
 174                 }
 175         }
 176         if (soap->error == SOAP_NO_TAG || soap->error == SOAP_EOF)
 177                 soap->error = SOAP_OK;
 178         return soap->error;
 179 }
 180 #endif
 181
 182 #ifndef WITH_NOIDREF
 183 SOAP_FMAC3 void * SOAP_FMAC4 soap_getelement(struct soap *soap, int *type)
 184 {
 185         if (soap_peek_element(soap))
 186                 return NULL;
 187         if (!*soap->id || !(*type = soap_lookup_type(soap, soap->id)))
 188                 *type = soap_lookup_type(soap, soap->href);
 189         switch (*type)
 190         {
 191         case SOAP_TYPE_KMS_CA_byte:
 192                 return soap_in_byte(soap, NULL, NULL, "xsd:byte");
 193         case SOAP_TYPE_KMS_CA_int:
 194                 return soap_in_int(soap, NULL, NULL, "xsd:int");
 195         case SOAP_TYPE_KMS_CA_xsd__int:
 196                 return soap_in_xsd__int(soap, NULL, NULL, "xsd:int");
 197         case SOAP_TYPE_KMS_CA_long:
 198                 return soap_in_long(soap, NULL, NULL, "xsd:long");
 199         case SOAP_TYPE_KMS_CA_xsd__long:
 200                 return soap_in_xsd__long(soap, NULL, NULL, "xsd:long");
 201         case SOAP_TYPE_KMS_CA_LONG64:
 202                 return soap_in_LONG64(soap, NULL, NULL, "xsd:long");
 203         case SOAP_TYPE_KMS_CA_xsd__float:
 204                 return soap_in_xsd__float(soap, NULL, NULL, "xsd:float");
 205         case SOAP_TYPE_KMS_CA_float:
 206                 return soap_in_float(soap, NULL, NULL, "xsd:float");
 207         case SOAP_TYPE_KMS_CA_unsignedByte:
 208                 return soap_in_unsignedByte(soap, NULL, NULL, "xsd:unsignedByte");
 209         case SOAP_TYPE_KMS_CA_unsignedInt:
 210                 return soap_in_unsignedInt(soap, NULL, NULL, "xsd:unsignedInt");
 211         case SOAP_TYPE_KMS_CA_xsd__boolean:
 212                 return soap_in_xsd__boolean(soap, NULL, NULL, "xsd:boolean");
 213         case SOAP_TYPE_KMS_CA_bool:
 214                 return soap_in_bool(soap, NULL, NULL, "xsd:boolean");
 215         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock:
 216                 return soap_in_KMS_CA__RetrieveLocalClock(soap, NULL, NULL, "KMS-CA:RetrieveLocalClock");
 217         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse:
 218                 return soap_in_KMS_CA__RetrieveLocalClockResponse(soap, NULL, NULL, "KMS-CA:RetrieveLocalClockResponse");
 219         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate:
 220                 return soap_in_KMS_CA__RetrieveRootCACertificate(soap, NULL, NULL, "KMS-CA:RetrieveRootCACertificate");
 221         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse:
 222                 return soap_in_KMS_CA__RetrieveRootCACertificateResponse(soap, NULL, NULL, "KMS-CA:RetrieveRootCACertificateResponse");
 223         case SOAP_TYPE_KMS_CA_xsd__hexBinary:
 224                 return soap_in_xsd__hexBinary(soap, NULL, NULL, "xsd:hexBinary");
 225         case SOAP_TYPE_KMS_CA_PointerTounsignedByte:
 226                 return soap_in_PointerTounsignedByte(soap, NULL, NULL, "xsd:unsignedByte");
 227         case SOAP_TYPE_KMS_CA_xsd__duration:
 228         {       char **s;
 229                 s = soap_in_xsd__duration(soap, NULL, NULL, "xsd:duration");
 230                 return s ? *s : NULL;
 231         }
 232         case SOAP_TYPE_KMS_CA_xsd__dateTime:
 233         {       char **s;
 234                 s = soap_in_xsd__dateTime(soap, NULL, NULL, "xsd:dateTime");
 235                 return s ? *s : NULL;
 236         }
 237         case SOAP_TYPE_KMS_CA_xsd__string:
 238         {       char **s;
 239                 s = soap_in_xsd__string(soap, NULL, NULL, "xsd:string");
 240                 return s ? *s : NULL;
 241         }
 242         case SOAP_TYPE_KMS_CA__QName:
 243         {       char **s;
 244                 s = soap_in__QName(soap, NULL, NULL, "xsd:QName");
 245                 return s ? *s : NULL;
 246         }
 247         case SOAP_TYPE_KMS_CA_string:
 248         {       char **s;
 249                 s = soap_in_string(soap, NULL, NULL, "xsd:string");
 250                 return s ? *s : NULL;
 251         }
 252         default:
 253         {       const char *t = soap->type;
 254                 if (!*t)
 255                         t = soap->tag;
 256                 if (!soap_match_tag(soap, t, "xsd:byte"))
 257                 {       *type = SOAP_TYPE_KMS_CA_byte;
 258                         return soap_in_byte(soap, NULL, NULL, NULL);
 259                 }
 260                 if (!soap_match_tag(soap, t, "xsd:int"))
 261                 {       *type = SOAP_TYPE_KMS_CA_int;
 262                         return soap_in_int(soap, NULL, NULL, NULL);
 263                 }
 264                 if (!soap_match_tag(soap, t, "xsd:int"))
 265                 {       *type = SOAP_TYPE_KMS_CA_xsd__int;
 266                         return soap_in_xsd__int(soap, NULL, NULL, NULL);
 267                 }
 268                 if (!soap_match_tag(soap, t, "xsd:long"))
 269                 {       *type = SOAP_TYPE_KMS_CA_long;
 270                         return soap_in_long(soap, NULL, NULL, NULL);
 271                 }
 272                 if (!soap_match_tag(soap, t, "xsd:long"))
 273                 {       *type = SOAP_TYPE_KMS_CA_xsd__long;
 274                         return soap_in_xsd__long(soap, NULL, NULL, NULL);
 275                 }
 276                 if (!soap_match_tag(soap, t, "xsd:long"))
 277                 {       *type = SOAP_TYPE_KMS_CA_LONG64;
 278                         return soap_in_LONG64(soap, NULL, NULL, NULL);
 279                 }
 280                 if (!soap_match_tag(soap, t, "xsd:float"))
 281                 {       *type = SOAP_TYPE_KMS_CA_xsd__float;
 282                         return soap_in_xsd__float(soap, NULL, NULL, NULL);
 283                 }
 284                 if (!soap_match_tag(soap, t, "xsd:float"))
 285                 {       *type = SOAP_TYPE_KMS_CA_float;
 286                         return soap_in_float(soap, NULL, NULL, NULL);
 287                 }
 288                 if (!soap_match_tag(soap, t, "xsd:unsignedByte"))
 289                 {       *type = SOAP_TYPE_KMS_CA_unsignedByte;
 290                         return soap_in_unsignedByte(soap, NULL, NULL, NULL);
 291                 }
 292                 if (!soap_match_tag(soap, t, "xsd:unsignedInt"))
 293                 {       *type = SOAP_TYPE_KMS_CA_unsignedInt;
 294                         return soap_in_unsignedInt(soap, NULL, NULL, NULL);
 295                 }
 296                 if (!soap_match_tag(soap, t, "xsd:boolean"))
 297                 {       *type = SOAP_TYPE_KMS_CA_xsd__boolean;
 298                         return soap_in_xsd__boolean(soap, NULL, NULL, NULL);
 299                 }
 300                 if (!soap_match_tag(soap, t, "xsd:boolean"))
 301                 {       *type = SOAP_TYPE_KMS_CA_bool;
 302                         return soap_in_bool(soap, NULL, NULL, NULL);
 303                 }
 304                 if (!soap_match_tag(soap, t, "KMS-CA:RetrieveLocalClock"))
 305                 {       *type = SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock;
 306                         return soap_in_KMS_CA__RetrieveLocalClock(soap, NULL, NULL, NULL);
 307                 }
 308                 if (!soap_match_tag(soap, t, "KMS-CA:RetrieveLocalClockResponse"))
 309                 {       *type = SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse;
 310                         return soap_in_KMS_CA__RetrieveLocalClockResponse(soap, NULL, NULL, NULL);
 311                 }
 312                 if (!soap_match_tag(soap, t, "KMS-CA:RetrieveRootCACertificate"))
 313                 {       *type = SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate;
 314                         return soap_in_KMS_CA__RetrieveRootCACertificate(soap, NULL, NULL, NULL);
 315                 }
 316                 if (!soap_match_tag(soap, t, "KMS-CA:RetrieveRootCACertificateResponse"))
 317                 {       *type = SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse;
 318                         return soap_in_KMS_CA__RetrieveRootCACertificateResponse(soap, NULL, NULL, NULL);
 319                 }
 320                 if (!soap_match_tag(soap, t, "xsd:hexBinary"))
 321                 {       *type = SOAP_TYPE_KMS_CA_xsd__hexBinary;
 322                         return soap_in_xsd__hexBinary(soap, NULL, NULL, NULL);
 323                 }
 324                 if (!soap_match_tag(soap, t, "xsd:duration"))
 325                 {       char **s;
 326                         *type = SOAP_TYPE_KMS_CA_xsd__duration;
 327                         s = soap_in_xsd__duration(soap, NULL, NULL, NULL);
 328                         return s ? *s : NULL;
 329                 }
 330                 if (!soap_match_tag(soap, t, "xsd:dateTime"))
 331                 {       char **s;
 332                         *type = SOAP_TYPE_KMS_CA_xsd__dateTime;
 333                         s = soap_in_xsd__dateTime(soap, NULL, NULL, NULL);
 334                         return s ? *s : NULL;
 335                 }
 336                 if (!soap_match_tag(soap, t, "xsd:string"))
 337                 {       char **s;
 338                         *type = SOAP_TYPE_KMS_CA_xsd__string;
 339                         s = soap_in_xsd__string(soap, NULL, NULL, NULL);
 340                         return s ? *s : NULL;
 341                 }
 342                 if (!soap_match_tag(soap, t, "xsd:QName"))
 343                 {       char **s;
 344                         *type = SOAP_TYPE_KMS_CA__QName;
 345                         s = soap_in__QName(soap, NULL, NULL, NULL);
 346                         return s ? *s : NULL;
 347                 }
 348                 if (!soap_match_tag(soap, t, "xsd:string"))
 349                 {       char **s;
 350                         *type = SOAP_TYPE_KMS_CA_string;
 351                         s = soap_in_string(soap, NULL, NULL, NULL);
 352                         return s ? *s : NULL;
 353                 }
 354                 t = soap->tag;
 355         }
 356         }
 357         soap->error = SOAP_TAG_MISMATCH;
 358         return NULL;
 359 }
 360 #endif
 361
 362 SOAP_FMAC3 int SOAP_FMAC4 soap_ignore_element(struct soap *soap)
 363 {
 364         if (!soap_peek_element(soap))
 365         {       int t;
 366                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Unexpected element '%s' in input (level=%u, %d)\n", soap->tag, soap->level, soap->body));
 367                 if (soap->mustUnderstand && !soap->other)
 368                         return soap->error = SOAP_MUSTUNDERSTAND;
 369                 if (((soap->mode & SOAP_XML_STRICT) && soap->part != SOAP_IN_HEADER) || !soap_match_tag(soap, soap->tag, "SOAP-ENV:"))
 370                 {       DBGLOG(TEST, SOAP_MESSAGE(fdebug, "REJECTING element '%s'\n", soap->tag));
 371                         return soap->error = SOAP_TAG_MISMATCH;
 372                 }
 373                 if (!*soap->id || !soap_getelement(soap, &t))
 374                 {       soap->peeked = 0;
 375                         if (soap->fignore)
 376                                 soap->error = soap->fignore(soap, soap->tag);
 377                         else
 378                                 soap->error = SOAP_OK;
 379                         DBGLOG(TEST, if (!soap->error) SOAP_MESSAGE(fdebug, "IGNORING element '%s'\n", soap->tag));
 380                         if (!soap->error && soap->body)
 381                         {       soap->level++;
 382                                 while (!soap_ignore_element(soap))
 383                                         ;
 384                                 if (soap->error == SOAP_NO_TAG)
 385                                         soap->error = soap_element_end_in(soap, NULL);
 386                         }
 387                 }
 388         }
 389         return soap->error;
 390 }
 391
 392 #ifndef WITH_NOIDREF
 393 SOAP_FMAC3 int SOAP_FMAC4 soap_putindependent(struct soap *soap)
 394 {
 395         int i;
 396         struct soap_plist *pp;
 397         if (soap->version == 1 && soap->encodingStyle && !(soap->mode & (SOAP_XML_TREE | SOAP_XML_GRAPH)))
 398                 for (i = 0; i < SOAP_PTRHASH; i++)
 399                         for (pp = soap->pht[i]; pp; pp = pp->next)
 400                                 if (pp->mark1 == 2 || pp->mark2 == 2)
 401                                         if (soap_putelement(soap, pp->ptr, "id", pp->id, pp->type))
 402                                                 return soap->error;
 403         return SOAP_OK;
 404 }
 405 #endif
 406
 407 #ifndef WITH_NOIDREF
 408 SOAP_FMAC3 int SOAP_FMAC4 soap_putelement(struct soap *soap, const void *ptr, const char *tag, int id, int type)
 409 {
 410         switch (type)
 411         {
 412         case SOAP_TYPE_KMS_CA_byte:
 413                 return soap_out_byte(soap, tag, id, (const char *)ptr, "xsd:byte");
 414         case SOAP_TYPE_KMS_CA_int:
 415                 return soap_out_int(soap, tag, id, (const int *)ptr, "xsd:int");
 416         case SOAP_TYPE_KMS_CA_xsd__int:
 417                 return soap_out_xsd__int(soap, tag, id, (const long *)ptr, "xsd:int");
 418         case SOAP_TYPE_KMS_CA_long:
 419                 return soap_out_long(soap, tag, id, (const long *)ptr, "xsd:long");
 420         case SOAP_TYPE_KMS_CA_xsd__long:
 421                 return soap_out_xsd__long(soap, tag, id, (const LONG64 *)ptr, "xsd:long");
 422         case SOAP_TYPE_KMS_CA_LONG64:
 423                 return soap_out_LONG64(soap, tag, id, (const LONG64 *)ptr, "xsd:long");
 424         case SOAP_TYPE_KMS_CA_xsd__float:
 425                 return soap_out_xsd__float(soap, tag, id, (const float *)ptr, "xsd:float");
 426         case SOAP_TYPE_KMS_CA_float:
 427                 return soap_out_float(soap, tag, id, (const float *)ptr, "xsd:float");
 428         case SOAP_TYPE_KMS_CA_unsignedByte:
 429                 return soap_out_unsignedByte(soap, tag, id, (const unsigned char *)ptr, "xsd:unsignedByte");
 430         case SOAP_TYPE_KMS_CA_unsignedInt:
 431                 return soap_out_unsignedInt(soap, tag, id, (const unsigned int *)ptr, "xsd:unsignedInt");
 432         case SOAP_TYPE_KMS_CA_xsd__boolean:
 433                 return soap_out_xsd__boolean(soap, tag, id, (const bool *)ptr, "xsd:boolean");
 434         case SOAP_TYPE_KMS_CA_bool:
 435                 return soap_out_bool(soap, tag, id, (const bool *)ptr, "xsd:boolean");
 436         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock:
 437                 return soap_out_KMS_CA__RetrieveLocalClock(soap, tag, id, (const struct KMS_CA__RetrieveLocalClock *)ptr, "KMS-CA:RetrieveLocalClock");
 438         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse:
 439                 return soap_out_KMS_CA__RetrieveLocalClockResponse(soap, tag, id, (const struct KMS_CA__RetrieveLocalClockResponse *)ptr, "KMS-CA:RetrieveLocalClockResponse");
 440         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate:
 441                 return soap_out_KMS_CA__RetrieveRootCACertificate(soap, tag, id, (const struct KMS_CA__RetrieveRootCACertificate *)ptr, "KMS-CA:RetrieveRootCACertificate");
 442         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse:
 443                 return soap_out_KMS_CA__RetrieveRootCACertificateResponse(soap, tag, id, (const struct KMS_CA__RetrieveRootCACertificateResponse *)ptr, "KMS-CA:RetrieveRootCACertificateResponse");
 444         case SOAP_TYPE_KMS_CA_xsd__hexBinary:
 445                 return soap_out_xsd__hexBinary(soap, tag, id, (const struct xsd__hexBinary *)ptr, "xsd:hexBinary");
 446         case SOAP_TYPE_KMS_CA_PointerTounsignedByte:
 447                 return soap_out_PointerTounsignedByte(soap, tag, id, (unsigned char *const*)ptr, "xsd:unsignedByte");
 448         case SOAP_TYPE_KMS_CA_xsd__duration:
 449                 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:duration");
 450         case SOAP_TYPE_KMS_CA_xsd__dateTime:
 451                 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:dateTime");
 452         case SOAP_TYPE_KMS_CA_xsd__string:
 453                 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
 454         case SOAP_TYPE_KMS_CA__QName:
 455                 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:QName");
 456         case SOAP_TYPE_KMS_CA_string:
 457                 return soap_out_string(soap, tag, id, (char*const*)&ptr, "xsd:string");
 458         }
 459         return SOAP_OK;
 460 }
 461 #endif
 462
 463 #ifndef WITH_NOIDREF
 464 SOAP_FMAC3 void SOAP_FMAC4 soap_markelement(struct soap *soap, const void *ptr, int type)
 465 {
 466         (void)soap; (void)ptr; (void)type; /* appease -Wall -Werror */
 467         switch (type)
 468         {
 469         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock:
 470                 soap_serialize_KMS_CA__RetrieveLocalClock(soap, (const struct KMS_CA__RetrieveLocalClock *)ptr);
 471                 break;
 472         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse:
 473                 soap_serialize_KMS_CA__RetrieveLocalClockResponse(soap, (const struct KMS_CA__RetrieveLocalClockResponse *)ptr);
 474                 break;
 475         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate:
 476                 soap_serialize_KMS_CA__RetrieveRootCACertificate(soap, (const struct KMS_CA__RetrieveRootCACertificate *)ptr);
 477                 break;
 478         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse:
 479                 soap_serialize_KMS_CA__RetrieveRootCACertificateResponse(soap, (const struct KMS_CA__RetrieveRootCACertificateResponse *)ptr);
 480                 break;
 481         case SOAP_TYPE_KMS_CA_xsd__hexBinary:
 482                 soap_serialize_xsd__hexBinary(soap, (const struct xsd__hexBinary *)ptr);
 483                 break;
 484         case SOAP_TYPE_KMS_CA_PointerTounsignedByte:
 485                 soap_serialize_PointerTounsignedByte(soap, (unsigned char *const*)ptr);
 486                 break;
 487         case SOAP_TYPE_KMS_CA_xsd__duration:
 488                 soap_serialize_string(soap, (char*const*)&ptr);
 489                 break;
 490         case SOAP_TYPE_KMS_CA_xsd__dateTime:
 491                 soap_serialize_string(soap, (char*const*)&ptr);
 492                 break;
 493         case SOAP_TYPE_KMS_CA_xsd__string:
 494                 soap_serialize_string(soap, (char*const*)&ptr);
 495                 break;
 496         case SOAP_TYPE_KMS_CA__QName:
 497                 soap_serialize_string(soap, (char*const*)&ptr);
 498                 break;
 499         case SOAP_TYPE_KMS_CA_string:
 500                 soap_serialize_string(soap, (char*const*)&ptr);
 501                 break;
 502         }
 503 }
 504 #endif
 505
 506 SOAP_FMAC3 void * SOAP_FMAC4 soap_instantiate(struct soap *soap, int t, const char *type, const char *arrayType, size_t *n)
 507 {
 508         switch (t)
 509         {
 510         case SOAP_TYPE_KMS_CA_xsd__hexBinary:
 511                 return (void*)soap_instantiate_xsd__hexBinary(soap, -1, type, arrayType, n);
 512         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse:
 513                 return (void*)soap_instantiate_KMS_CA__RetrieveRootCACertificateResponse(soap, -1, type, arrayType, n);
 514         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate:
 515                 return (void*)soap_instantiate_KMS_CA__RetrieveRootCACertificate(soap, -1, type, arrayType, n);
 516         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse:
 517                 return (void*)soap_instantiate_KMS_CA__RetrieveLocalClockResponse(soap, -1, type, arrayType, n);
 518         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock:
 519                 return (void*)soap_instantiate_KMS_CA__RetrieveLocalClock(soap, -1, type, arrayType, n);
 520 #ifndef WITH_NOGLOBAL
 521         case SOAP_TYPE_KMS_CA_SOAP_ENV__Header:
 522                 return (void*)soap_instantiate_SOAP_ENV__Header(soap, -1, type, arrayType, n);
 523 #endif
 524 #ifndef WITH_NOGLOBAL
 525         case SOAP_TYPE_KMS_CA_SOAP_ENV__Code:
 526                 return (void*)soap_instantiate_SOAP_ENV__Code(soap, -1, type, arrayType, n);
 527 #endif
 528 #ifndef WITH_NOGLOBAL
 529         case SOAP_TYPE_KMS_CA_SOAP_ENV__Detail:
 530                 return (void*)soap_instantiate_SOAP_ENV__Detail(soap, -1, type, arrayType, n);
 531 #endif
 532 #ifndef WITH_NOGLOBAL
 533         case SOAP_TYPE_KMS_CA_SOAP_ENV__Reason:
 534                 return (void*)soap_instantiate_SOAP_ENV__Reason(soap, -1, type, arrayType, n);
 535 #endif
 536 #ifndef WITH_NOGLOBAL
 537         case SOAP_TYPE_KMS_CA_SOAP_ENV__Fault:
 538                 return (void*)soap_instantiate_SOAP_ENV__Fault(soap, -1, type, arrayType, n);
 539 #endif
 540         }
 541         return NULL;
 542 }
 543
 544 SOAP_FMAC3 int SOAP_FMAC4 soap_fdelete(struct soap_clist *p)
 545 {       switch (p->type)
 546         {
 547         case SOAP_TYPE_KMS_CA_xsd__hexBinary:
 548                 if (p->size < 0)
 549                         SOAP_DELETE((struct xsd__hexBinary*)p->ptr);
 550                 else
 551                         SOAP_DELETE_ARRAY((struct xsd__hexBinary*)p->ptr);
 552                 break;
 553         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse:
 554                 if (p->size < 0)
 555                         SOAP_DELETE((struct KMS_CA__RetrieveRootCACertificateResponse*)p->ptr);
 556                 else
 557                         SOAP_DELETE_ARRAY((struct KMS_CA__RetrieveRootCACertificateResponse*)p->ptr);
 558                 break;
 559         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate:
 560                 if (p->size < 0)
 561                         SOAP_DELETE((struct KMS_CA__RetrieveRootCACertificate*)p->ptr);
 562                 else
 563                         SOAP_DELETE_ARRAY((struct KMS_CA__RetrieveRootCACertificate*)p->ptr);
 564                 break;
 565         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse:
 566                 if (p->size < 0)
 567                         SOAP_DELETE((struct KMS_CA__RetrieveLocalClockResponse*)p->ptr);
 568                 else
 569                         SOAP_DELETE_ARRAY((struct KMS_CA__RetrieveLocalClockResponse*)p->ptr);
 570                 break;
 571         case SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock:
 572                 if (p->size < 0)
 573                         SOAP_DELETE((struct KMS_CA__RetrieveLocalClock*)p->ptr);
 574                 else
 575                         SOAP_DELETE_ARRAY((struct KMS_CA__RetrieveLocalClock*)p->ptr);
 576                 break;
 577         case SOAP_TYPE_KMS_CA_SOAP_ENV__Header:
 578                 if (p->size < 0)
 579                         SOAP_DELETE((struct SOAP_ENV__Header*)p->ptr);
 580                 else
 581                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Header*)p->ptr);
 582                 break;
 583         case SOAP_TYPE_KMS_CA_SOAP_ENV__Code:
 584                 if (p->size < 0)
 585                         SOAP_DELETE((struct SOAP_ENV__Code*)p->ptr);
 586                 else
 587                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Code*)p->ptr);
 588                 break;
 589         case SOAP_TYPE_KMS_CA_SOAP_ENV__Detail:
 590                 if (p->size < 0)
 591                         SOAP_DELETE((struct SOAP_ENV__Detail*)p->ptr);
 592                 else
 593                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Detail*)p->ptr);
 594                 break;
 595         case SOAP_TYPE_KMS_CA_SOAP_ENV__Reason:
 596                 if (p->size < 0)
 597                         SOAP_DELETE((struct SOAP_ENV__Reason*)p->ptr);
 598                 else
 599                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Reason*)p->ptr);
 600                 break;
 601         case SOAP_TYPE_KMS_CA_SOAP_ENV__Fault:
 602                 if (p->size < 0)
 603                         SOAP_DELETE((struct SOAP_ENV__Fault*)p->ptr);
 604                 else
 605                         SOAP_DELETE_ARRAY((struct SOAP_ENV__Fault*)p->ptr);
 606                 break;
 607         default:        return SOAP_ERR;
 608         }
 609         return SOAP_OK;
 610 }
 611
 612 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)
 613 {       return soap_id_enter(soap, id, p, t, n, 0, type, arrayType, soap_instantiate);
 614 }
 615
 616 SOAP_FMAC3 void SOAP_FMAC4 soap_default_byte(struct soap *soap, char *a)
 617 {
 618         (void)soap; /* appease -Wall -Werror */
 619 #ifdef SOAP_DEFAULT_byte
 620         *a = SOAP_DEFAULT_byte;
 621 #else
 622         *a = (char)0;
 623 #endif
 624 }
 625
 626 SOAP_FMAC3 int SOAP_FMAC4 soap_out_byte(struct soap *soap, const char *tag, int id, const char *a, const char *type)
 627 {
 628         return soap_outbyte(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_byte);
 629 }
 630
 631 SOAP_FMAC3 char * SOAP_FMAC4 soap_in_byte(struct soap *soap, const char *tag, char *a, const char *type)
 632 {       char *p;
 633         p = soap_inbyte(soap, tag, a, type, SOAP_TYPE_KMS_CA_byte);
 634         return p;
 635 }
 636
 637 SOAP_FMAC3 int SOAP_FMAC4 soap_put_byte(struct soap *soap, const char *a, const char *tag, const char *type)
 638 {
 639         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_byte);
 640         if (soap_out_byte(soap, tag?tag:"byte", id, a, type))
 641                 return soap->error;
 642         return soap_putindependent(soap);
 643 }
 644
 645 SOAP_FMAC3 char * SOAP_FMAC4 soap_get_byte(struct soap *soap, char *p, const char *tag, const char *type)
 646 {
 647         if ((p = soap_in_byte(soap, tag, p, type)))
 648                 if (soap_getindependent(soap))
 649                         return NULL;
 650         return p;
 651 }
 652
 653 SOAP_FMAC3 void SOAP_FMAC4 soap_default_int(struct soap *soap, int *a)
 654 {
 655         (void)soap; /* appease -Wall -Werror */
 656 #ifdef SOAP_DEFAULT_int
 657         *a = SOAP_DEFAULT_int;
 658 #else
 659         *a = (int)0;
 660 #endif
 661 }
 662
 663 SOAP_FMAC3 int SOAP_FMAC4 soap_out_int(struct soap *soap, const char *tag, int id, const int *a, const char *type)
 664 {
 665         return soap_outint(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_int);
 666 }
 667
 668 SOAP_FMAC3 int * SOAP_FMAC4 soap_in_int(struct soap *soap, const char *tag, int *a, const char *type)
 669 {       int *p;
 670         p = soap_inint(soap, tag, a, type, SOAP_TYPE_KMS_CA_int);
 671         return p;
 672 }
 673
 674 SOAP_FMAC3 int SOAP_FMAC4 soap_put_int(struct soap *soap, const int *a, const char *tag, const char *type)
 675 {
 676         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_int);
 677         if (soap_out_int(soap, tag?tag:"int", id, a, type))
 678                 return soap->error;
 679         return soap_putindependent(soap);
 680 }
 681
 682 SOAP_FMAC3 int * SOAP_FMAC4 soap_get_int(struct soap *soap, int *p, const char *tag, const char *type)
 683 {
 684         if ((p = soap_in_int(soap, tag, p, type)))
 685                 if (soap_getindependent(soap))
 686                         return NULL;
 687         return p;
 688 }
 689
 690 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__int(struct soap *soap, const char *tag, int id, const long *a, const char *type)
 691 {
 692         return soap_outlong(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_xsd__int);
 693 }
 694
 695 SOAP_FMAC3 long * SOAP_FMAC4 soap_in_xsd__int(struct soap *soap, const char *tag, long *a, const char *type)
 696 {       long *p;
 697         p = soap_inlong(soap, tag, a, type, SOAP_TYPE_KMS_CA_xsd__int);
 698         return p;
 699 }
 700
 701 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__int(struct soap *soap, const long *a, const char *tag, const char *type)
 702 {
 703         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_xsd__int);
 704         if (soap_out_xsd__int(soap, tag?tag:"xsd:int", id, a, type))
 705                 return soap->error;
 706         return soap_putindependent(soap);
 707 }
 708
 709 SOAP_FMAC3 long * SOAP_FMAC4 soap_get_xsd__int(struct soap *soap, long *p, const char *tag, const char *type)
 710 {
 711         if ((p = soap_in_xsd__int(soap, tag, p, type)))
 712                 if (soap_getindependent(soap))
 713                         return NULL;
 714         return p;
 715 }
 716
 717 SOAP_FMAC3 void SOAP_FMAC4 soap_default_long(struct soap *soap, long *a)
 718 {
 719         (void)soap; /* appease -Wall -Werror */
 720 #ifdef SOAP_DEFAULT_long
 721         *a = SOAP_DEFAULT_long;
 722 #else
 723         *a = (long)0;
 724 #endif
 725 }
 726
 727 SOAP_FMAC3 int SOAP_FMAC4 soap_out_long(struct soap *soap, const char *tag, int id, const long *a, const char *type)
 728 {
 729         return soap_outlong(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_long);
 730 }
 731
 732 SOAP_FMAC3 long * SOAP_FMAC4 soap_in_long(struct soap *soap, const char *tag, long *a, const char *type)
 733 {       long *p;
 734         p = soap_inlong(soap, tag, a, type, SOAP_TYPE_KMS_CA_long);
 735         return p;
 736 }
 737
 738 SOAP_FMAC3 int SOAP_FMAC4 soap_put_long(struct soap *soap, const long *a, const char *tag, const char *type)
 739 {
 740         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_long);
 741         if (soap_out_long(soap, tag?tag:"long", id, a, type))
 742                 return soap->error;
 743         return soap_putindependent(soap);
 744 }
 745
 746 SOAP_FMAC3 long * SOAP_FMAC4 soap_get_long(struct soap *soap, long *p, const char *tag, const char *type)
 747 {
 748         if ((p = soap_in_long(soap, tag, p, type)))
 749                 if (soap_getindependent(soap))
 750                         return NULL;
 751         return p;
 752 }
 753
 754 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__long(struct soap *soap, const char *tag, int id, const LONG64 *a, const char *type)
 755 {
 756         return soap_outLONG64(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_xsd__long);
 757 }
 758
 759 SOAP_FMAC3 LONG64 * SOAP_FMAC4 soap_in_xsd__long(struct soap *soap, const char *tag, LONG64 *a, const char *type)
 760 {       LONG64 *p;
 761         p = soap_inLONG64(soap, tag, a, type, SOAP_TYPE_KMS_CA_xsd__long);
 762         return p;
 763 }
 764
 765 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__long(struct soap *soap, const LONG64 *a, const char *tag, const char *type)
 766 {
 767         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_xsd__long);
 768         if (soap_out_xsd__long(soap, tag?tag:"xsd:long", id, a, type))
 769                 return soap->error;
 770         return soap_putindependent(soap);
 771 }
 772
 773 SOAP_FMAC3 LONG64 * SOAP_FMAC4 soap_get_xsd__long(struct soap *soap, LONG64 *p, const char *tag, const char *type)
 774 {
 775         if ((p = soap_in_xsd__long(soap, tag, p, type)))
 776                 if (soap_getindependent(soap))
 777                         return NULL;
 778         return p;
 779 }
 780
 781 SOAP_FMAC3 void SOAP_FMAC4 soap_default_LONG64(struct soap *soap, LONG64 *a)
 782 {
 783         (void)soap; /* appease -Wall -Werror */
 784 #ifdef SOAP_DEFAULT_LONG64
 785         *a = SOAP_DEFAULT_LONG64;
 786 #else
 787         *a = (LONG64)0;
 788 #endif
 789 }
 790
 791 SOAP_FMAC3 int SOAP_FMAC4 soap_out_LONG64(struct soap *soap, const char *tag, int id, const LONG64 *a, const char *type)
 792 {
 793         return soap_outLONG64(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_LONG64);
 794 }
 795
 796 SOAP_FMAC3 LONG64 * SOAP_FMAC4 soap_in_LONG64(struct soap *soap, const char *tag, LONG64 *a, const char *type)
 797 {       LONG64 *p;
 798         p = soap_inLONG64(soap, tag, a, type, SOAP_TYPE_KMS_CA_LONG64);
 799         return p;
 800 }
 801
 802 SOAP_FMAC3 int SOAP_FMAC4 soap_put_LONG64(struct soap *soap, const LONG64 *a, const char *tag, const char *type)
 803 {
 804         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_LONG64);
 805         if (soap_out_LONG64(soap, tag?tag:"long", id, a, type))
 806                 return soap->error;
 807         return soap_putindependent(soap);
 808 }
 809
 810 SOAP_FMAC3 LONG64 * SOAP_FMAC4 soap_get_LONG64(struct soap *soap, LONG64 *p, const char *tag, const char *type)
 811 {
 812         if ((p = soap_in_LONG64(soap, tag, p, type)))
 813                 if (soap_getindependent(soap))
 814                         return NULL;
 815         return p;
 816 }
 817
 818 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__float(struct soap *soap, const char *tag, int id, const float *a, const char *type)
 819 {
 820         return soap_outfloat(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_xsd__float);
 821 }
 822
 823 SOAP_FMAC3 float * SOAP_FMAC4 soap_in_xsd__float(struct soap *soap, const char *tag, float *a, const char *type)
 824 {       float *p;
 825         p = soap_infloat(soap, tag, a, type, SOAP_TYPE_KMS_CA_xsd__float);
 826         return p;
 827 }
 828
 829 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__float(struct soap *soap, const float *a, const char *tag, const char *type)
 830 {
 831         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_xsd__float);
 832         if (soap_out_xsd__float(soap, tag?tag:"xsd:float", id, a, type))
 833                 return soap->error;
 834         return soap_putindependent(soap);
 835 }
 836
 837 SOAP_FMAC3 float * SOAP_FMAC4 soap_get_xsd__float(struct soap *soap, float *p, const char *tag, const char *type)
 838 {
 839         if ((p = soap_in_xsd__float(soap, tag, p, type)))
 840                 if (soap_getindependent(soap))
 841                         return NULL;
 842         return p;
 843 }
 844
 845 SOAP_FMAC3 void SOAP_FMAC4 soap_default_float(struct soap *soap, float *a)
 846 {
 847         (void)soap; /* appease -Wall -Werror */
 848 #ifdef SOAP_DEFAULT_float
 849         *a = SOAP_DEFAULT_float;
 850 #else
 851         *a = (float)0;
 852 #endif
 853 }
 854
 855 SOAP_FMAC3 int SOAP_FMAC4 soap_out_float(struct soap *soap, const char *tag, int id, const float *a, const char *type)
 856 {
 857         return soap_outfloat(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_float);
 858 }
 859
 860 SOAP_FMAC3 float * SOAP_FMAC4 soap_in_float(struct soap *soap, const char *tag, float *a, const char *type)
 861 {       float *p;
 862         p = soap_infloat(soap, tag, a, type, SOAP_TYPE_KMS_CA_float);
 863         return p;
 864 }
 865
 866 SOAP_FMAC3 int SOAP_FMAC4 soap_put_float(struct soap *soap, const float *a, const char *tag, const char *type)
 867 {
 868         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_float);
 869         if (soap_out_float(soap, tag?tag:"float", id, a, type))
 870                 return soap->error;
 871         return soap_putindependent(soap);
 872 }
 873
 874 SOAP_FMAC3 float * SOAP_FMAC4 soap_get_float(struct soap *soap, float *p, const char *tag, const char *type)
 875 {
 876         if ((p = soap_in_float(soap, tag, p, type)))
 877                 if (soap_getindependent(soap))
 878                         return NULL;
 879         return p;
 880 }
 881
 882 SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedByte(struct soap *soap, unsigned char *a)
 883 {
 884         (void)soap; /* appease -Wall -Werror */
 885 #ifdef SOAP_DEFAULT_unsignedByte
 886         *a = SOAP_DEFAULT_unsignedByte;
 887 #else
 888         *a = (unsigned char)0;
 889 #endif
 890 }
 891
 892 SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedByte(struct soap *soap, const char *tag, int id, const unsigned char *a, const char *type)
 893 {
 894         return soap_outunsignedByte(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_unsignedByte);
 895 }
 896
 897 SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_in_unsignedByte(struct soap *soap, const char *tag, unsigned char *a, const char *type)
 898 {       unsigned char *p;
 899         p = soap_inunsignedByte(soap, tag, a, type, SOAP_TYPE_KMS_CA_unsignedByte);
 900         return p;
 901 }
 902
 903 SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedByte(struct soap *soap, const unsigned char *a, const char *tag, const char *type)
 904 {
 905         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_unsignedByte);
 906         if (soap_out_unsignedByte(soap, tag?tag:"unsignedByte", id, a, type))
 907                 return soap->error;
 908         return soap_putindependent(soap);
 909 }
 910
 911 SOAP_FMAC3 unsigned char * SOAP_FMAC4 soap_get_unsignedByte(struct soap *soap, unsigned char *p, const char *tag, const char *type)
 912 {
 913         if ((p = soap_in_unsignedByte(soap, tag, p, type)))
 914                 if (soap_getindependent(soap))
 915                         return NULL;
 916         return p;
 917 }
 918
 919 SOAP_FMAC3 void SOAP_FMAC4 soap_default_unsignedInt(struct soap *soap, unsigned int *a)
 920 {
 921         (void)soap; /* appease -Wall -Werror */
 922 #ifdef SOAP_DEFAULT_unsignedInt
 923         *a = SOAP_DEFAULT_unsignedInt;
 924 #else
 925         *a = (unsigned int)0;
 926 #endif
 927 }
 928
 929 SOAP_FMAC3 int SOAP_FMAC4 soap_out_unsignedInt(struct soap *soap, const char *tag, int id, const unsigned int *a, const char *type)
 930 {
 931         return soap_outunsignedInt(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_unsignedInt);
 932 }
 933
 934 SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_in_unsignedInt(struct soap *soap, const char *tag, unsigned int *a, const char *type)
 935 {       unsigned int *p;
 936         p = soap_inunsignedInt(soap, tag, a, type, SOAP_TYPE_KMS_CA_unsignedInt);
 937         return p;
 938 }
 939
 940 SOAP_FMAC3 int SOAP_FMAC4 soap_put_unsignedInt(struct soap *soap, const unsigned int *a, const char *tag, const char *type)
 941 {
 942         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_unsignedInt);
 943         if (soap_out_unsignedInt(soap, tag?tag:"unsignedInt", id, a, type))
 944                 return soap->error;
 945         return soap_putindependent(soap);
 946 }
 947
 948 SOAP_FMAC3 unsigned int * SOAP_FMAC4 soap_get_unsignedInt(struct soap *soap, unsigned int *p, const char *tag, const char *type)
 949 {
 950         if ((p = soap_in_unsignedInt(soap, tag, p, type)))
 951                 if (soap_getindependent(soap))
 952                         return NULL;
 953         return p;
 954 }
 955
 956 SOAP_FMAC3S const char* SOAP_FMAC4S soap_xsd__boolean2s(struct soap *soap, bool n)
 957 {       return soap_bool2s(soap, n);
 958 }
 959
 960 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__boolean(struct soap *soap, const char *tag, int id, const bool *a, const char *type)
 961 {       if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_xsd__boolean), type) || soap_send(soap, soap_xsd__boolean2s(soap, *a)))
 962                 return soap->error;
 963         return soap_element_end_out(soap, tag);
 964 }
 965
 966 SOAP_FMAC3S int SOAP_FMAC4S soap_s2xsd__boolean(struct soap *soap, const char *s, bool *a)
 967 {
 968         return soap_s2bool(soap, s, a);
 969 }
 970
 971 SOAP_FMAC3 bool * SOAP_FMAC4 soap_in_xsd__boolean(struct soap *soap, const char *tag, bool *a, const char *type)
 972 {
 973         if (soap_element_begin_in(soap, tag, 0, NULL))
 974                 return NULL;
 975         if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":boolean"))
 976         {       soap->error = SOAP_TYPE;
 977                 return NULL;
 978         }
 979         a = (bool *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_xsd__boolean, sizeof(bool), 0, NULL, NULL, NULL);
 980         if (!a)
 981                 return NULL;
 982         if (soap->body && !*soap->href)
 983         {       if (!a || soap_s2xsd__boolean(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
 984                         return NULL;
 985         }
 986         else
 987         {       a = (bool *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_xsd__boolean, 0, sizeof(bool), 0, NULL);
 988                 if (soap->body && soap_element_end_in(soap, tag))
 989                         return NULL;
 990         }
 991         return a;
 992 }
 993
 994 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__boolean(struct soap *soap, const bool *a, const char *tag, const char *type)
 995 {
 996         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_xsd__boolean);
 997         if (soap_out_xsd__boolean(soap, tag?tag:"xsd:boolean", id, a, type))
 998                 return soap->error;
 999         return soap_putindependent(soap);
1000 }
1001
1002 SOAP_FMAC3 bool * SOAP_FMAC4 soap_get_xsd__boolean(struct soap *soap, bool *p, const char *tag, const char *type)
1003 {
1004         if ((p = soap_in_xsd__boolean(soap, tag, p, type)))
1005                 if (soap_getindependent(soap))
1006                         return NULL;
1007         return p;
1008 }
1009
1010 SOAP_FMAC3 void SOAP_FMAC4 soap_default_bool(struct soap *soap, bool *a)
1011 {
1012         (void)soap; /* appease -Wall -Werror */
1013 #ifdef SOAP_DEFAULT_bool
1014         *a = SOAP_DEFAULT_bool;
1015 #else
1016         *a = (bool)0;
1017 #endif
1018 }
1019
1020 static const struct soap_code_map soap_codes_bool[] =
1021 {       { (long)false, "false" },
1022         { (long)true, "true" },
1023         { 0, NULL }
1024 };
1025
1026 SOAP_FMAC3S const char* SOAP_FMAC4S soap_bool2s(struct soap *soap, bool n)
1027 {
1028         (void)soap; /* appease -Wall -Werror */
1029 return soap_code_str(soap_codes_bool, n!=0);
1030 }
1031
1032 SOAP_FMAC3 int SOAP_FMAC4 soap_out_bool(struct soap *soap, const char *tag, int id, const bool *a, const char *type)
1033 {       if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_bool), type) || soap_send(soap, soap_bool2s(soap, *a)))
1034                 return soap->error;
1035         return soap_element_end_out(soap, tag);
1036 }
1037
1038 SOAP_FMAC3S int SOAP_FMAC4S soap_s2bool(struct soap *soap, const char *s, bool *a)
1039 {
1040         const struct soap_code_map *map;
1041         if (!s)
1042                 return soap->error;
1043         map = soap_code(soap_codes_bool, s);
1044         if (map)
1045                 *a = (bool)(map->code != 0);
1046         else
1047         {       long n;
1048                 if (soap_s2long(soap, s, &n) || n < 0 || n > 1)
1049                         return soap->error = SOAP_TYPE;
1050                 *a = (bool)(n != 0);
1051         }
1052         return SOAP_OK;
1053 }
1054
1055 SOAP_FMAC3 bool * SOAP_FMAC4 soap_in_bool(struct soap *soap, const char *tag, bool *a, const char *type)
1056 {
1057         if (soap_element_begin_in(soap, tag, 0, NULL))
1058                 return NULL;
1059         if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":boolean"))
1060         {       soap->error = SOAP_TYPE;
1061                 return NULL;
1062         }
1063         a = (bool *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_bool, sizeof(bool), 0, NULL, NULL, NULL);
1064         if (!a)
1065                 return NULL;
1066         if (soap->body && !*soap->href)
1067         {       if (!a || soap_s2bool(soap, soap_value(soap), a) || soap_element_end_in(soap, tag))
1068                         return NULL;
1069         }
1070         else
1071         {       a = (bool *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_bool, 0, sizeof(bool), 0, NULL);
1072                 if (soap->body && soap_element_end_in(soap, tag))
1073                         return NULL;
1074         }
1075         return a;
1076 }
1077
1078 SOAP_FMAC3 int SOAP_FMAC4 soap_put_bool(struct soap *soap, const bool *a, const char *tag, const char *type)
1079 {
1080         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_bool);
1081         if (soap_out_bool(soap, tag?tag:"boolean", id, a, type))
1082                 return soap->error;
1083         return soap_putindependent(soap);
1084 }
1085
1086 SOAP_FMAC3 bool * SOAP_FMAC4 soap_get_bool(struct soap *soap, bool *p, const char *tag, const char *type)
1087 {
1088         if ((p = soap_in_bool(soap, tag, p, type)))
1089                 if (soap_getindependent(soap))
1090                         return NULL;
1091         return p;
1092 }
1093
1094 #ifndef WITH_NOGLOBAL
1095
1096 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Fault(struct soap *soap, struct SOAP_ENV__Fault *a)
1097 {
1098         (void)soap; (void)a; /* appease -Wall -Werror */
1099         soap_default__QName(soap, &a->faultcode);
1100         soap_default_string(soap, &a->faultstring);
1101         soap_default_string(soap, &a->faultactor);
1102         a->detail = NULL;
1103         a->SOAP_ENV__Code = NULL;
1104         a->SOAP_ENV__Reason = NULL;
1105         soap_default_string(soap, &a->SOAP_ENV__Node);
1106         soap_default_string(soap, &a->SOAP_ENV__Role);
1107         a->SOAP_ENV__Detail = NULL;
1108 }
1109
1110 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Fault(struct soap *soap, const struct SOAP_ENV__Fault *a)
1111 {
1112         (void)soap; (void)a; /* appease -Wall -Werror */
1113         soap_serialize__QName(soap, &a->faultcode);
1114         soap_serialize_string(soap, &a->faultstring);
1115         soap_serialize_string(soap, &a->faultactor);
1116         soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->detail);
1117         soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Code);
1118         soap_serialize_PointerToSOAP_ENV__Reason(soap, &a->SOAP_ENV__Reason);
1119         soap_serialize_string(soap, &a->SOAP_ENV__Node);
1120         soap_serialize_string(soap, &a->SOAP_ENV__Role);
1121         soap_serialize_PointerToSOAP_ENV__Detail(soap, &a->SOAP_ENV__Detail);
1122 }
1123
1124 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)
1125 {
1126         const char *soap_tmp_faultcode = soap_QName2s(soap, a->faultcode);
1127         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Fault), type))
1128                 return soap->error;
1129         if (soap_out__QName(soap, "faultcode", -1, (char*const*)&soap_tmp_faultcode, ""))
1130                 return soap->error;
1131         if (soap_out_string(soap, "faultstring", -1, &a->faultstring, "xsd:string"))
1132                 return soap->error;
1133         if (soap_out_string(soap, "faultactor", -1, &a->faultactor, "xsd:string"))
1134                 return soap->error;
1135         if (soap_out_PointerToSOAP_ENV__Detail(soap, "detail", -1, &a->detail, ""))
1136                 return soap->error;
1137         if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", -1, &a->SOAP_ENV__Code, ""))
1138                 return soap->error;
1139         if (soap_out_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", -1, &a->SOAP_ENV__Reason, ""))
1140                 return soap->error;
1141         if (soap_out_string(soap, "SOAP-ENV:Node", -1, &a->SOAP_ENV__Node, ""))
1142                 return soap->error;
1143         if (soap_out_string(soap, "SOAP-ENV:Role", -1, &a->SOAP_ENV__Role, ""))
1144                 return soap->error;
1145         if (soap_out_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", -1, &a->SOAP_ENV__Detail, ""))
1146                 return soap->error;
1147         return soap_element_end_out(soap, tag);
1148 }
1149
1150 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)
1151 {
1152         size_t soap_flag_faultcode = 1;
1153         size_t soap_flag_faultstring = 1;
1154         size_t soap_flag_faultactor = 1;
1155         size_t soap_flag_detail = 1;
1156         size_t soap_flag_SOAP_ENV__Code = 1;
1157         size_t soap_flag_SOAP_ENV__Reason = 1;
1158         size_t soap_flag_SOAP_ENV__Node = 1;
1159         size_t soap_flag_SOAP_ENV__Role = 1;
1160         size_t soap_flag_SOAP_ENV__Detail = 1;
1161         if (soap_element_begin_in(soap, tag, 0, type))
1162                 return NULL;
1163         a = (struct SOAP_ENV__Fault *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Fault, sizeof(struct SOAP_ENV__Fault), 0, NULL, NULL, NULL);
1164         if (!a)
1165                 return NULL;
1166         soap_default_SOAP_ENV__Fault(soap, a);
1167         if (soap->body && !*soap->href)
1168         {
1169                 for (;;)
1170                 {       soap->error = SOAP_TAG_MISMATCH;
1171                         if (soap_flag_faultcode && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1172                                 if (soap_in__QName(soap, "faultcode", &a->faultcode, ""))
1173                                 {       soap_flag_faultcode--;
1174                                         continue;
1175                                 }
1176                         if (soap_flag_faultstring && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1177                                 if (soap_in_string(soap, "faultstring", &a->faultstring, "xsd:string"))
1178                                 {       soap_flag_faultstring--;
1179                                         continue;
1180                                 }
1181                         if (soap_flag_faultactor && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1182                                 if (soap_in_string(soap, "faultactor", &a->faultactor, "xsd:string"))
1183                                 {       soap_flag_faultactor--;
1184                                         continue;
1185                                 }
1186                         if (soap_flag_detail && soap->error == SOAP_TAG_MISMATCH)
1187                                 if (soap_in_PointerToSOAP_ENV__Detail(soap, "detail", &a->detail, ""))
1188                                 {       soap_flag_detail--;
1189                                         continue;
1190                                 }
1191                         if (soap_flag_SOAP_ENV__Code && soap->error == SOAP_TAG_MISMATCH)
1192                                 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Code", &a->SOAP_ENV__Code, ""))
1193                                 {       soap_flag_SOAP_ENV__Code--;
1194                                         continue;
1195                                 }
1196                         if (soap_flag_SOAP_ENV__Reason && soap->error == SOAP_TAG_MISMATCH)
1197                                 if (soap_in_PointerToSOAP_ENV__Reason(soap, "SOAP-ENV:Reason", &a->SOAP_ENV__Reason, ""))
1198                                 {       soap_flag_SOAP_ENV__Reason--;
1199                                         continue;
1200                                 }
1201                         if (soap_flag_SOAP_ENV__Node && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1202                                 if (soap_in_string(soap, "SOAP-ENV:Node", &a->SOAP_ENV__Node, "xsd:string"))
1203                                 {       soap_flag_SOAP_ENV__Node--;
1204                                         continue;
1205                                 }
1206                         if (soap_flag_SOAP_ENV__Role && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1207                                 if (soap_in_string(soap, "SOAP-ENV:Role", &a->SOAP_ENV__Role, "xsd:string"))
1208                                 {       soap_flag_SOAP_ENV__Role--;
1209                                         continue;
1210                                 }
1211                         if (soap_flag_SOAP_ENV__Detail && soap->error == SOAP_TAG_MISMATCH)
1212                                 if (soap_in_PointerToSOAP_ENV__Detail(soap, "SOAP-ENV:Detail", &a->SOAP_ENV__Detail, ""))
1213                                 {       soap_flag_SOAP_ENV__Detail--;
1214                                         continue;
1215                                 }
1216                         if (soap->error == SOAP_TAG_MISMATCH)
1217                                 soap->error = soap_ignore_element(soap);
1218                         if (soap->error == SOAP_NO_TAG)
1219                                 break;
1220                         if (soap->error)
1221                                 return NULL;
1222                 }
1223                 if (soap_element_end_in(soap, tag))
1224                         return NULL;
1225         }
1226         else
1227         {       a = (struct SOAP_ENV__Fault *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_SOAP_ENV__Fault, 0, sizeof(struct SOAP_ENV__Fault), 0, NULL);
1228                 if (soap->body && soap_element_end_in(soap, tag))
1229                         return NULL;
1230         }
1231         return a;
1232 }
1233
1234 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)
1235 {
1236         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_SOAP_ENV__Fault);
1237         if (soap_out_SOAP_ENV__Fault(soap, tag?tag:"SOAP-ENV:Fault", id, a, type))
1238                 return soap->error;
1239         return soap_putindependent(soap);
1240 }
1241
1242 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)
1243 {
1244         if ((p = soap_in_SOAP_ENV__Fault(soap, tag, p, type)))
1245                 if (soap_getindependent(soap))
1246                         return NULL;
1247         return p;
1248 }
1249
1250 SOAP_FMAC1 struct SOAP_ENV__Fault * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Fault(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
1251 {
1252         (void)type; (void)arrayType; /* appease -Wall -Werror */
1253         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Fault(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
1254         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_SOAP_ENV__Fault, n, soap_fdelete);
1255         if (!cp)
1256                 return NULL;
1257         if (n < 0)
1258         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Fault);
1259                 if (size)
1260                         *size = sizeof(struct SOAP_ENV__Fault);
1261         }
1262         else
1263         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Fault[n]);
1264                 if (!cp->ptr)
1265                 {       soap->error = SOAP_EOM;
1266                         return NULL;
1267                 }
1268                 if (size)
1269                         *size = n * sizeof(struct SOAP_ENV__Fault);
1270         }
1271                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1272         return (struct SOAP_ENV__Fault*)cp->ptr;
1273 }
1274
1275 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)
1276 {
1277         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1278         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Fault %p -> %p\n", q, p));
1279         *(struct SOAP_ENV__Fault*)p = *(struct SOAP_ENV__Fault*)q;
1280 }
1281
1282 #endif
1283
1284 #ifndef WITH_NOGLOBAL
1285
1286 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *a)
1287 {
1288         (void)soap; (void)a; /* appease -Wall -Werror */
1289         soap_default_string(soap, &a->SOAP_ENV__Text);
1290 }
1291
1292 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Reason(struct soap *soap, const struct SOAP_ENV__Reason *a)
1293 {
1294         (void)soap; (void)a; /* appease -Wall -Werror */
1295         soap_serialize_string(soap, &a->SOAP_ENV__Text);
1296 }
1297
1298 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)
1299 {
1300         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Reason), type))
1301                 return soap->error;
1302         if (soap->lang)
1303                 soap_set_attr(soap, "xml:lang", soap->lang, 1);
1304         if (soap_out_string(soap, "SOAP-ENV:Text", -1, &a->SOAP_ENV__Text, ""))
1305                 return soap->error;
1306         return soap_element_end_out(soap, tag);
1307 }
1308
1309 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)
1310 {
1311         size_t soap_flag_SOAP_ENV__Text = 1;
1312         if (soap_element_begin_in(soap, tag, 0, type))
1313                 return NULL;
1314         a = (struct SOAP_ENV__Reason *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0, NULL, NULL, NULL);
1315         if (!a)
1316                 return NULL;
1317         soap_default_SOAP_ENV__Reason(soap, a);
1318         if (soap->body && !*soap->href)
1319         {
1320                 for (;;)
1321                 {       soap->error = SOAP_TAG_MISMATCH;
1322                         if (soap_flag_SOAP_ENV__Text && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1323                                 if (soap_in_string(soap, "SOAP-ENV:Text", &a->SOAP_ENV__Text, "xsd:string"))
1324                                 {       soap_flag_SOAP_ENV__Text--;
1325                                         continue;
1326                                 }
1327                         if (soap->error == SOAP_TAG_MISMATCH)
1328                                 soap->error = soap_ignore_element(soap);
1329                         if (soap->error == SOAP_NO_TAG)
1330                                 break;
1331                         if (soap->error)
1332                                 return NULL;
1333                 }
1334                 if (soap_element_end_in(soap, tag))
1335                         return NULL;
1336         }
1337         else
1338         {       a = (struct SOAP_ENV__Reason *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_SOAP_ENV__Reason, 0, sizeof(struct SOAP_ENV__Reason), 0, NULL);
1339                 if (soap->body && soap_element_end_in(soap, tag))
1340                         return NULL;
1341         }
1342         return a;
1343 }
1344
1345 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)
1346 {
1347         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_SOAP_ENV__Reason);
1348         if (soap_out_SOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, a, type))
1349                 return soap->error;
1350         return soap_putindependent(soap);
1351 }
1352
1353 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)
1354 {
1355         if ((p = soap_in_SOAP_ENV__Reason(soap, tag, p, type)))
1356                 if (soap_getindependent(soap))
1357                         return NULL;
1358         return p;
1359 }
1360
1361 SOAP_FMAC1 struct SOAP_ENV__Reason * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Reason(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
1362 {
1363         (void)type; (void)arrayType; /* appease -Wall -Werror */
1364         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Reason(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
1365         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_SOAP_ENV__Reason, n, soap_fdelete);
1366         if (!cp)
1367                 return NULL;
1368         if (n < 0)
1369         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Reason);
1370                 if (size)
1371                         *size = sizeof(struct SOAP_ENV__Reason);
1372         }
1373         else
1374         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Reason[n]);
1375                 if (!cp->ptr)
1376                 {       soap->error = SOAP_EOM;
1377                         return NULL;
1378                 }
1379                 if (size)
1380                         *size = n * sizeof(struct SOAP_ENV__Reason);
1381         }
1382                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1383         return (struct SOAP_ENV__Reason*)cp->ptr;
1384 }
1385
1386 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)
1387 {
1388         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1389         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Reason %p -> %p\n", q, p));
1390         *(struct SOAP_ENV__Reason*)p = *(struct SOAP_ENV__Reason*)q;
1391 }
1392
1393 #endif
1394
1395 #ifndef WITH_NOGLOBAL
1396
1397 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *a)
1398 {
1399         (void)soap; (void)a; /* appease -Wall -Werror */
1400         a->__type = 0;
1401         a->fault = NULL;
1402         a->__any = NULL;
1403 }
1404
1405 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Detail(struct soap *soap, const struct SOAP_ENV__Detail *a)
1406 {
1407         (void)soap; (void)a; /* appease -Wall -Werror */
1408         soap_markelement(soap, a->fault, a->__type);
1409 }
1410
1411 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)
1412 {
1413         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Detail), type))
1414                 return soap->error;
1415         if (soap_putelement(soap, a->fault, "fault", -1, a->__type))
1416                 return soap->error;
1417         soap_outliteral(soap, "-any", &a->__any, NULL);
1418         return soap_element_end_out(soap, tag);
1419 }
1420
1421 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)
1422 {
1423         size_t soap_flag_fault = 1;
1424         size_t soap_flag___any = 1;
1425         if (soap_element_begin_in(soap, tag, 0, type))
1426                 return NULL;
1427         a = (struct SOAP_ENV__Detail *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0, NULL, NULL, NULL);
1428         if (!a)
1429                 return NULL;
1430         soap_default_SOAP_ENV__Detail(soap, a);
1431         if (soap->body && !*soap->href)
1432         {
1433                 for (;;)
1434                 {       soap->error = SOAP_TAG_MISMATCH;
1435                         if (soap_flag_fault && soap->error == SOAP_TAG_MISMATCH)
1436                                 if ((a->fault = soap_getelement(soap, &a->__type)))
1437                                 {       soap_flag_fault = 0;
1438                                         continue;
1439                                 }
1440                         if (soap_flag___any && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1441                                 if (soap_inliteral(soap, "-any", &a->__any))
1442                                 {       soap_flag___any--;
1443                                         continue;
1444                                 }
1445                         if (soap->error == SOAP_TAG_MISMATCH)
1446                                 soap->error = soap_ignore_element(soap);
1447                         if (soap->error == SOAP_NO_TAG)
1448                                 break;
1449                         if (soap->error)
1450                                 return NULL;
1451                 }
1452                 if (soap_element_end_in(soap, tag))
1453                         return NULL;
1454         }
1455         else
1456         {       a = (struct SOAP_ENV__Detail *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_SOAP_ENV__Detail, 0, sizeof(struct SOAP_ENV__Detail), 0, NULL);
1457                 if (soap->body && soap_element_end_in(soap, tag))
1458                         return NULL;
1459         }
1460         return a;
1461 }
1462
1463 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)
1464 {
1465         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_SOAP_ENV__Detail);
1466         if (soap_out_SOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, a, type))
1467                 return soap->error;
1468         return soap_putindependent(soap);
1469 }
1470
1471 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)
1472 {
1473         if ((p = soap_in_SOAP_ENV__Detail(soap, tag, p, type)))
1474                 if (soap_getindependent(soap))
1475                         return NULL;
1476         return p;
1477 }
1478
1479 SOAP_FMAC1 struct SOAP_ENV__Detail * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Detail(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
1480 {
1481         (void)type; (void)arrayType; /* appease -Wall -Werror */
1482         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Detail(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
1483         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_SOAP_ENV__Detail, n, soap_fdelete);
1484         if (!cp)
1485                 return NULL;
1486         if (n < 0)
1487         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Detail);
1488                 if (size)
1489                         *size = sizeof(struct SOAP_ENV__Detail);
1490         }
1491         else
1492         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Detail[n]);
1493                 if (!cp->ptr)
1494                 {       soap->error = SOAP_EOM;
1495                         return NULL;
1496                 }
1497                 if (size)
1498                         *size = n * sizeof(struct SOAP_ENV__Detail);
1499         }
1500                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1501         return (struct SOAP_ENV__Detail*)cp->ptr;
1502 }
1503
1504 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)
1505 {
1506         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1507         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Detail %p -> %p\n", q, p));
1508         *(struct SOAP_ENV__Detail*)p = *(struct SOAP_ENV__Detail*)q;
1509 }
1510
1511 #endif
1512
1513 #ifndef WITH_NOGLOBAL
1514
1515 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *a)
1516 {
1517         (void)soap; (void)a; /* appease -Wall -Werror */
1518         soap_default__QName(soap, &a->SOAP_ENV__Value);
1519         a->SOAP_ENV__Subcode = NULL;
1520 }
1521
1522 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Code(struct soap *soap, const struct SOAP_ENV__Code *a)
1523 {
1524         (void)soap; (void)a; /* appease -Wall -Werror */
1525         soap_serialize__QName(soap, &a->SOAP_ENV__Value);
1526         soap_serialize_PointerToSOAP_ENV__Code(soap, &a->SOAP_ENV__Subcode);
1527 }
1528
1529 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)
1530 {
1531         const char *soap_tmp_SOAP_ENV__Value = soap_QName2s(soap, a->SOAP_ENV__Value);
1532         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Code), type))
1533                 return soap->error;
1534         if (soap_out__QName(soap, "SOAP-ENV:Value", -1, (char*const*)&soap_tmp_SOAP_ENV__Value, ""))
1535                 return soap->error;
1536         if (soap_out_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", -1, &a->SOAP_ENV__Subcode, ""))
1537                 return soap->error;
1538         return soap_element_end_out(soap, tag);
1539 }
1540
1541 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)
1542 {
1543         size_t soap_flag_SOAP_ENV__Value = 1;
1544         size_t soap_flag_SOAP_ENV__Subcode = 1;
1545         if (soap_element_begin_in(soap, tag, 0, type))
1546                 return NULL;
1547         a = (struct SOAP_ENV__Code *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0, NULL, NULL, NULL);
1548         if (!a)
1549                 return NULL;
1550         soap_default_SOAP_ENV__Code(soap, a);
1551         if (soap->body && !*soap->href)
1552         {
1553                 for (;;)
1554                 {       soap->error = SOAP_TAG_MISMATCH;
1555                         if (soap_flag_SOAP_ENV__Value && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1556                                 if (soap_in__QName(soap, "SOAP-ENV:Value", &a->SOAP_ENV__Value, ""))
1557                                 {       soap_flag_SOAP_ENV__Value--;
1558                                         continue;
1559                                 }
1560                         if (soap_flag_SOAP_ENV__Subcode && soap->error == SOAP_TAG_MISMATCH)
1561                                 if (soap_in_PointerToSOAP_ENV__Code(soap, "SOAP-ENV:Subcode", &a->SOAP_ENV__Subcode, ""))
1562                                 {       soap_flag_SOAP_ENV__Subcode--;
1563                                         continue;
1564                                 }
1565                         if (soap->error == SOAP_TAG_MISMATCH)
1566                                 soap->error = soap_ignore_element(soap);
1567                         if (soap->error == SOAP_NO_TAG)
1568                                 break;
1569                         if (soap->error)
1570                                 return NULL;
1571                 }
1572                 if (soap_element_end_in(soap, tag))
1573                         return NULL;
1574         }
1575         else
1576         {       a = (struct SOAP_ENV__Code *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_SOAP_ENV__Code, 0, sizeof(struct SOAP_ENV__Code), 0, NULL);
1577                 if (soap->body && soap_element_end_in(soap, tag))
1578                         return NULL;
1579         }
1580         return a;
1581 }
1582
1583 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)
1584 {
1585         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_SOAP_ENV__Code);
1586         if (soap_out_SOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, a, type))
1587                 return soap->error;
1588         return soap_putindependent(soap);
1589 }
1590
1591 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)
1592 {
1593         if ((p = soap_in_SOAP_ENV__Code(soap, tag, p, type)))
1594                 if (soap_getindependent(soap))
1595                         return NULL;
1596         return p;
1597 }
1598
1599 SOAP_FMAC1 struct SOAP_ENV__Code * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Code(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
1600 {
1601         (void)type; (void)arrayType; /* appease -Wall -Werror */
1602         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Code(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
1603         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_SOAP_ENV__Code, n, soap_fdelete);
1604         if (!cp)
1605                 return NULL;
1606         if (n < 0)
1607         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Code);
1608                 if (size)
1609                         *size = sizeof(struct SOAP_ENV__Code);
1610         }
1611         else
1612         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Code[n]);
1613                 if (!cp->ptr)
1614                 {       soap->error = SOAP_EOM;
1615                         return NULL;
1616                 }
1617                 if (size)
1618                         *size = n * sizeof(struct SOAP_ENV__Code);
1619         }
1620                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1621         return (struct SOAP_ENV__Code*)cp->ptr;
1622 }
1623
1624 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)
1625 {
1626         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1627         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Code %p -> %p\n", q, p));
1628         *(struct SOAP_ENV__Code*)p = *(struct SOAP_ENV__Code*)q;
1629 }
1630
1631 #endif
1632
1633 #ifndef WITH_NOGLOBAL
1634
1635 SOAP_FMAC3 void SOAP_FMAC4 soap_default_SOAP_ENV__Header(struct soap *soap, struct SOAP_ENV__Header *a)
1636 {
1637         (void)soap; (void)a; /* appease -Wall -Werror */
1638 }
1639
1640 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_SOAP_ENV__Header(struct soap *soap, const struct SOAP_ENV__Header *a)
1641 {
1642         (void)soap; (void)a; /* appease -Wall -Werror */
1643 }
1644
1645 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)
1646 {
1647         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Header), type))
1648                 return soap->error;
1649         return soap_element_end_out(soap, tag);
1650 }
1651
1652 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)
1653 {
1654         if (soap_element_begin_in(soap, tag, 0, type))
1655                 return NULL;
1656         a = (struct SOAP_ENV__Header *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_SOAP_ENV__Header, sizeof(struct SOAP_ENV__Header), 0, NULL, NULL, NULL);
1657         if (!a)
1658                 return NULL;
1659         soap_default_SOAP_ENV__Header(soap, a);
1660         if (soap->body && !*soap->href)
1661         {
1662                 for (;;)
1663                 {       soap->error = SOAP_TAG_MISMATCH;
1664                         if (soap->error == SOAP_TAG_MISMATCH)
1665                                 soap->error = soap_ignore_element(soap);
1666                         if (soap->error == SOAP_NO_TAG)
1667                                 break;
1668                         if (soap->error)
1669                                 return NULL;
1670                 }
1671                 if (soap_element_end_in(soap, tag))
1672                         return NULL;
1673         }
1674         else
1675         {       a = (struct SOAP_ENV__Header *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_SOAP_ENV__Header, 0, sizeof(struct SOAP_ENV__Header), 0, NULL);
1676                 if (soap->body && soap_element_end_in(soap, tag))
1677                         return NULL;
1678         }
1679         return a;
1680 }
1681
1682 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)
1683 {
1684         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_SOAP_ENV__Header);
1685         if (soap_out_SOAP_ENV__Header(soap, tag?tag:"SOAP-ENV:Header", id, a, type))
1686                 return soap->error;
1687         return soap_putindependent(soap);
1688 }
1689
1690 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)
1691 {
1692         if ((p = soap_in_SOAP_ENV__Header(soap, tag, p, type)))
1693                 if (soap_getindependent(soap))
1694                         return NULL;
1695         return p;
1696 }
1697
1698 SOAP_FMAC1 struct SOAP_ENV__Header * SOAP_FMAC2 soap_instantiate_SOAP_ENV__Header(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
1699 {
1700         (void)type; (void)arrayType; /* appease -Wall -Werror */
1701         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_SOAP_ENV__Header(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
1702         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_SOAP_ENV__Header, n, soap_fdelete);
1703         if (!cp)
1704                 return NULL;
1705         if (n < 0)
1706         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Header);
1707                 if (size)
1708                         *size = sizeof(struct SOAP_ENV__Header);
1709         }
1710         else
1711         {       cp->ptr = (void*)SOAP_NEW(struct SOAP_ENV__Header[n]);
1712                 if (!cp->ptr)
1713                 {       soap->error = SOAP_EOM;
1714                         return NULL;
1715                 }
1716                 if (size)
1717                         *size = n * sizeof(struct SOAP_ENV__Header);
1718         }
1719                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1720         return (struct SOAP_ENV__Header*)cp->ptr;
1721 }
1722
1723 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)
1724 {
1725         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1726         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct SOAP_ENV__Header %p -> %p\n", q, p));
1727         *(struct SOAP_ENV__Header*)p = *(struct SOAP_ENV__Header*)q;
1728 }
1729
1730 #endif
1731
1732 SOAP_FMAC3 void SOAP_FMAC4 soap_default_KMS_CA__RetrieveLocalClock(struct soap *soap, struct KMS_CA__RetrieveLocalClock *a)
1733 {
1734         (void)soap; (void)a; /* appease -Wall -Werror */
1735         soap_default_xsd__string(soap, &a->EntityID);
1736 }
1737
1738 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_KMS_CA__RetrieveLocalClock(struct soap *soap, const struct KMS_CA__RetrieveLocalClock *a)
1739 {
1740         (void)soap; (void)a; /* appease -Wall -Werror */
1741         soap_serialize_xsd__string(soap, &a->EntityID);
1742 }
1743
1744 SOAP_FMAC3 int SOAP_FMAC4 soap_out_KMS_CA__RetrieveLocalClock(struct soap *soap, const char *tag, int id, const struct KMS_CA__RetrieveLocalClock *a, const char *type)
1745 {
1746         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock), type))
1747                 return soap->error;
1748         if (soap_out_xsd__string(soap, "EntityID", -1, &a->EntityID, "xsd:string"))
1749                 return soap->error;
1750         return soap_element_end_out(soap, tag);
1751 }
1752
1753 SOAP_FMAC3 struct KMS_CA__RetrieveLocalClock * SOAP_FMAC4 soap_in_KMS_CA__RetrieveLocalClock(struct soap *soap, const char *tag, struct KMS_CA__RetrieveLocalClock *a, const char *type)
1754 {
1755         size_t soap_flag_EntityID = 1;
1756         if (soap_element_begin_in(soap, tag, 0, type))
1757                 return NULL;
1758         a = (struct KMS_CA__RetrieveLocalClock *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock, sizeof(struct KMS_CA__RetrieveLocalClock), 0, NULL, NULL, NULL);
1759         if (!a)
1760                 return NULL;
1761         soap_default_KMS_CA__RetrieveLocalClock(soap, a);
1762         if (soap->body && !*soap->href)
1763         {
1764                 for (;;)
1765                 {       soap->error = SOAP_TAG_MISMATCH;
1766                         if (soap_flag_EntityID && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1767                                 if (soap_in_xsd__string(soap, "EntityID", &a->EntityID, "xsd:string"))
1768                                 {       soap_flag_EntityID--;
1769                                         continue;
1770                                 }
1771                         if (soap->error == SOAP_TAG_MISMATCH)
1772                                 soap->error = soap_ignore_element(soap);
1773                         if (soap->error == SOAP_NO_TAG)
1774                                 break;
1775                         if (soap->error)
1776                                 return NULL;
1777                 }
1778                 if (soap_element_end_in(soap, tag))
1779                         return NULL;
1780         }
1781         else
1782         {       a = (struct KMS_CA__RetrieveLocalClock *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock, 0, sizeof(struct KMS_CA__RetrieveLocalClock), 0, NULL);
1783                 if (soap->body && soap_element_end_in(soap, tag))
1784                         return NULL;
1785         }
1786         return a;
1787 }
1788
1789 SOAP_FMAC3 int SOAP_FMAC4 soap_put_KMS_CA__RetrieveLocalClock(struct soap *soap, const struct KMS_CA__RetrieveLocalClock *a, const char *tag, const char *type)
1790 {
1791         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock);
1792         if (soap_out_KMS_CA__RetrieveLocalClock(soap, tag?tag:"KMS-CA:RetrieveLocalClock", id, a, type))
1793                 return soap->error;
1794         return soap_putindependent(soap);
1795 }
1796
1797 SOAP_FMAC3 struct KMS_CA__RetrieveLocalClock * SOAP_FMAC4 soap_get_KMS_CA__RetrieveLocalClock(struct soap *soap, struct KMS_CA__RetrieveLocalClock *p, const char *tag, const char *type)
1798 {
1799         if ((p = soap_in_KMS_CA__RetrieveLocalClock(soap, tag, p, type)))
1800                 if (soap_getindependent(soap))
1801                         return NULL;
1802         return p;
1803 }
1804
1805 SOAP_FMAC1 struct KMS_CA__RetrieveLocalClock * SOAP_FMAC2 soap_instantiate_KMS_CA__RetrieveLocalClock(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
1806 {
1807         (void)type; (void)arrayType; /* appease -Wall -Werror */
1808         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_KMS_CA__RetrieveLocalClock(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
1809         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClock, n, soap_fdelete);
1810         if (!cp)
1811                 return NULL;
1812         if (n < 0)
1813         {       cp->ptr = (void*)SOAP_NEW(struct KMS_CA__RetrieveLocalClock);
1814                 if (size)
1815                         *size = sizeof(struct KMS_CA__RetrieveLocalClock);
1816         }
1817         else
1818         {       cp->ptr = (void*)SOAP_NEW(struct KMS_CA__RetrieveLocalClock[n]);
1819                 if (!cp->ptr)
1820                 {       soap->error = SOAP_EOM;
1821                         return NULL;
1822                 }
1823                 if (size)
1824                         *size = n * sizeof(struct KMS_CA__RetrieveLocalClock);
1825         }
1826                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1827         return (struct KMS_CA__RetrieveLocalClock*)cp->ptr;
1828 }
1829
1830 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_KMS_CA__RetrieveLocalClock(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
1831 {
1832         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1833         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct KMS_CA__RetrieveLocalClock %p -> %p\n", q, p));
1834         *(struct KMS_CA__RetrieveLocalClock*)p = *(struct KMS_CA__RetrieveLocalClock*)q;
1835 }
1836
1837 SOAP_FMAC3 void SOAP_FMAC4 soap_default_KMS_CA__RetrieveLocalClockResponse(struct soap *soap, struct KMS_CA__RetrieveLocalClockResponse *a)
1838 {
1839         (void)soap; (void)a; /* appease -Wall -Werror */
1840         soap_default_xsd__dateTime(soap, &a->CurrentTime);
1841 }
1842
1843 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_KMS_CA__RetrieveLocalClockResponse(struct soap *soap, const struct KMS_CA__RetrieveLocalClockResponse *a)
1844 {
1845         (void)soap; (void)a; /* appease -Wall -Werror */
1846         soap_serialize_xsd__dateTime(soap, &a->CurrentTime);
1847 }
1848
1849 SOAP_FMAC3 int SOAP_FMAC4 soap_out_KMS_CA__RetrieveLocalClockResponse(struct soap *soap, const char *tag, int id, const struct KMS_CA__RetrieveLocalClockResponse *a, const char *type)
1850 {
1851         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse), type))
1852                 return soap->error;
1853         if (soap_out_xsd__dateTime(soap, "CurrentTime", -1, &a->CurrentTime, "xsd:dateTime"))
1854                 return soap->error;
1855         return soap_element_end_out(soap, tag);
1856 }
1857
1858 SOAP_FMAC3 struct KMS_CA__RetrieveLocalClockResponse * SOAP_FMAC4 soap_in_KMS_CA__RetrieveLocalClockResponse(struct soap *soap, const char *tag, struct KMS_CA__RetrieveLocalClockResponse *a, const char *type)
1859 {
1860         size_t soap_flag_CurrentTime = 1;
1861         if (soap_element_begin_in(soap, tag, 0, type))
1862                 return NULL;
1863         a = (struct KMS_CA__RetrieveLocalClockResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse, sizeof(struct KMS_CA__RetrieveLocalClockResponse), 0, NULL, NULL, NULL);
1864         if (!a)
1865                 return NULL;
1866         soap_default_KMS_CA__RetrieveLocalClockResponse(soap, a);
1867         if (soap->body && !*soap->href)
1868         {
1869                 for (;;)
1870                 {       soap->error = SOAP_TAG_MISMATCH;
1871                         if (soap_flag_CurrentTime && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1872                                 if (soap_in_xsd__dateTime(soap, "CurrentTime", &a->CurrentTime, "xsd:dateTime"))
1873                                 {       soap_flag_CurrentTime--;
1874                                         continue;
1875                                 }
1876                         if (soap->error == SOAP_TAG_MISMATCH)
1877                                 soap->error = soap_ignore_element(soap);
1878                         if (soap->error == SOAP_NO_TAG)
1879                                 break;
1880                         if (soap->error)
1881                                 return NULL;
1882                 }
1883                 if (soap_element_end_in(soap, tag))
1884                         return NULL;
1885         }
1886         else
1887         {       a = (struct KMS_CA__RetrieveLocalClockResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse, 0, sizeof(struct KMS_CA__RetrieveLocalClockResponse), 0, NULL);
1888                 if (soap->body && soap_element_end_in(soap, tag))
1889                         return NULL;
1890         }
1891         return a;
1892 }
1893
1894 SOAP_FMAC3 int SOAP_FMAC4 soap_put_KMS_CA__RetrieveLocalClockResponse(struct soap *soap, const struct KMS_CA__RetrieveLocalClockResponse *a, const char *tag, const char *type)
1895 {
1896         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse);
1897         if (soap_out_KMS_CA__RetrieveLocalClockResponse(soap, tag?tag:"KMS-CA:RetrieveLocalClockResponse", id, a, type))
1898                 return soap->error;
1899         return soap_putindependent(soap);
1900 }
1901
1902 SOAP_FMAC3 struct KMS_CA__RetrieveLocalClockResponse * SOAP_FMAC4 soap_get_KMS_CA__RetrieveLocalClockResponse(struct soap *soap, struct KMS_CA__RetrieveLocalClockResponse *p, const char *tag, const char *type)
1903 {
1904         if ((p = soap_in_KMS_CA__RetrieveLocalClockResponse(soap, tag, p, type)))
1905                 if (soap_getindependent(soap))
1906                         return NULL;
1907         return p;
1908 }
1909
1910 SOAP_FMAC1 struct KMS_CA__RetrieveLocalClockResponse * SOAP_FMAC2 soap_instantiate_KMS_CA__RetrieveLocalClockResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
1911 {
1912         (void)type; (void)arrayType; /* appease -Wall -Werror */
1913         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_KMS_CA__RetrieveLocalClockResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
1914         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveLocalClockResponse, n, soap_fdelete);
1915         if (!cp)
1916                 return NULL;
1917         if (n < 0)
1918         {       cp->ptr = (void*)SOAP_NEW(struct KMS_CA__RetrieveLocalClockResponse);
1919                 if (size)
1920                         *size = sizeof(struct KMS_CA__RetrieveLocalClockResponse);
1921         }
1922         else
1923         {       cp->ptr = (void*)SOAP_NEW(struct KMS_CA__RetrieveLocalClockResponse[n]);
1924                 if (!cp->ptr)
1925                 {       soap->error = SOAP_EOM;
1926                         return NULL;
1927                 }
1928                 if (size)
1929                         *size = n * sizeof(struct KMS_CA__RetrieveLocalClockResponse);
1930         }
1931                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
1932         return (struct KMS_CA__RetrieveLocalClockResponse*)cp->ptr;
1933 }
1934
1935 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_KMS_CA__RetrieveLocalClockResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
1936 {
1937         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
1938         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct KMS_CA__RetrieveLocalClockResponse %p -> %p\n", q, p));
1939         *(struct KMS_CA__RetrieveLocalClockResponse*)p = *(struct KMS_CA__RetrieveLocalClockResponse*)q;
1940 }
1941
1942 SOAP_FMAC3 void SOAP_FMAC4 soap_default_KMS_CA__RetrieveRootCACertificate(struct soap *soap, struct KMS_CA__RetrieveRootCACertificate *a)
1943 {
1944         (void)soap; (void)a; /* appease -Wall -Werror */
1945         soap_default_xsd__string(soap, &a->EntityID);
1946 }
1947
1948 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_KMS_CA__RetrieveRootCACertificate(struct soap *soap, const struct KMS_CA__RetrieveRootCACertificate *a)
1949 {
1950         (void)soap; (void)a; /* appease -Wall -Werror */
1951         soap_serialize_xsd__string(soap, &a->EntityID);
1952 }
1953
1954 SOAP_FMAC3 int SOAP_FMAC4 soap_out_KMS_CA__RetrieveRootCACertificate(struct soap *soap, const char *tag, int id, const struct KMS_CA__RetrieveRootCACertificate *a, const char *type)
1955 {
1956         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate), type))
1957                 return soap->error;
1958         if (soap_out_xsd__string(soap, "EntityID", -1, &a->EntityID, "xsd:string"))
1959                 return soap->error;
1960         return soap_element_end_out(soap, tag);
1961 }
1962
1963 SOAP_FMAC3 struct KMS_CA__RetrieveRootCACertificate * SOAP_FMAC4 soap_in_KMS_CA__RetrieveRootCACertificate(struct soap *soap, const char *tag, struct KMS_CA__RetrieveRootCACertificate *a, const char *type)
1964 {
1965         size_t soap_flag_EntityID = 1;
1966         if (soap_element_begin_in(soap, tag, 0, type))
1967                 return NULL;
1968         a = (struct KMS_CA__RetrieveRootCACertificate *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate, sizeof(struct KMS_CA__RetrieveRootCACertificate), 0, NULL, NULL, NULL);
1969         if (!a)
1970                 return NULL;
1971         soap_default_KMS_CA__RetrieveRootCACertificate(soap, a);
1972         if (soap->body && !*soap->href)
1973         {
1974                 for (;;)
1975                 {       soap->error = SOAP_TAG_MISMATCH;
1976                         if (soap_flag_EntityID && (soap->error == SOAP_TAG_MISMATCH || soap->error == SOAP_NO_TAG))
1977                                 if (soap_in_xsd__string(soap, "EntityID", &a->EntityID, "xsd:string"))
1978                                 {       soap_flag_EntityID--;
1979                                         continue;
1980                                 }
1981                         if (soap->error == SOAP_TAG_MISMATCH)
1982                                 soap->error = soap_ignore_element(soap);
1983                         if (soap->error == SOAP_NO_TAG)
1984                                 break;
1985                         if (soap->error)
1986                                 return NULL;
1987                 }
1988                 if (soap_element_end_in(soap, tag))
1989                         return NULL;
1990         }
1991         else
1992         {       a = (struct KMS_CA__RetrieveRootCACertificate *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate, 0, sizeof(struct KMS_CA__RetrieveRootCACertificate), 0, NULL);
1993                 if (soap->body && soap_element_end_in(soap, tag))
1994                         return NULL;
1995         }
1996         return a;
1997 }
1998
1999 SOAP_FMAC3 int SOAP_FMAC4 soap_put_KMS_CA__RetrieveRootCACertificate(struct soap *soap, const struct KMS_CA__RetrieveRootCACertificate *a, const char *tag, const char *type)
2000 {
2001         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate);
2002         if (soap_out_KMS_CA__RetrieveRootCACertificate(soap, tag?tag:"KMS-CA:RetrieveRootCACertificate", id, a, type))
2003                 return soap->error;
2004         return soap_putindependent(soap);
2005 }
2006
2007 SOAP_FMAC3 struct KMS_CA__RetrieveRootCACertificate * SOAP_FMAC4 soap_get_KMS_CA__RetrieveRootCACertificate(struct soap *soap, struct KMS_CA__RetrieveRootCACertificate *p, const char *tag, const char *type)
2008 {
2009         if ((p = soap_in_KMS_CA__RetrieveRootCACertificate(soap, tag, p, type)))
2010                 if (soap_getindependent(soap))
2011                         return NULL;
2012         return p;
2013 }
2014
2015 SOAP_FMAC1 struct KMS_CA__RetrieveRootCACertificate * SOAP_FMAC2 soap_instantiate_KMS_CA__RetrieveRootCACertificate(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
2016 {
2017         (void)type; (void)arrayType; /* appease -Wall -Werror */
2018         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_KMS_CA__RetrieveRootCACertificate(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
2019         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificate, n, soap_fdelete);
2020         if (!cp)
2021                 return NULL;
2022         if (n < 0)
2023         {       cp->ptr = (void*)SOAP_NEW(struct KMS_CA__RetrieveRootCACertificate);
2024                 if (size)
2025                         *size = sizeof(struct KMS_CA__RetrieveRootCACertificate);
2026         }
2027         else
2028         {       cp->ptr = (void*)SOAP_NEW(struct KMS_CA__RetrieveRootCACertificate[n]);
2029                 if (!cp->ptr)
2030                 {       soap->error = SOAP_EOM;
2031                         return NULL;
2032                 }
2033                 if (size)
2034                         *size = n * sizeof(struct KMS_CA__RetrieveRootCACertificate);
2035         }
2036                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
2037         return (struct KMS_CA__RetrieveRootCACertificate*)cp->ptr;
2038 }
2039
2040 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_KMS_CA__RetrieveRootCACertificate(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
2041 {
2042         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
2043         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct KMS_CA__RetrieveRootCACertificate %p -> %p\n", q, p));
2044         *(struct KMS_CA__RetrieveRootCACertificate*)p = *(struct KMS_CA__RetrieveRootCACertificate*)q;
2045 }
2046
2047 SOAP_FMAC3 void SOAP_FMAC4 soap_default_KMS_CA__RetrieveRootCACertificateResponse(struct soap *soap, struct KMS_CA__RetrieveRootCACertificateResponse *a)
2048 {
2049         (void)soap; (void)a; /* appease -Wall -Werror */
2050         soap_default_xsd__hexBinary(soap, &a->RootCACertificate);
2051         soap_default_xsd__int(soap, &a->AuthenticationHashIterationCount);
2052         soap_default_xsd__hexBinary(soap, &a->ClientAuthenticationChallenge);
2053 }
2054
2055 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_KMS_CA__RetrieveRootCACertificateResponse(struct soap *soap, const struct KMS_CA__RetrieveRootCACertificateResponse *a)
2056 {
2057         (void)soap; (void)a; /* appease -Wall -Werror */
2058         soap_serialize_xsd__hexBinary(soap, &a->RootCACertificate);
2059         soap_serialize_xsd__hexBinary(soap, &a->ClientAuthenticationChallenge);
2060 }
2061
2062 SOAP_FMAC3 int SOAP_FMAC4 soap_out_KMS_CA__RetrieveRootCACertificateResponse(struct soap *soap, const char *tag, int id, const struct KMS_CA__RetrieveRootCACertificateResponse *a, const char *type)
2063 {
2064         if (soap_element_begin_out(soap, tag, soap_embedded_id(soap, id, a, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse), type))
2065                 return soap->error;
2066         if (soap_out_xsd__hexBinary(soap, "RootCACertificate", -1, &a->RootCACertificate, "xsd:hexBinary"))
2067                 return soap->error;
2068         if (soap_out_xsd__int(soap, "AuthenticationHashIterationCount", -1, &a->AuthenticationHashIterationCount, "xsd:int"))
2069                 return soap->error;
2070         if (soap_out_xsd__hexBinary(soap, "ClientAuthenticationChallenge", -1, &a->ClientAuthenticationChallenge, "xsd:hexBinary"))
2071                 return soap->error;
2072         return soap_element_end_out(soap, tag);
2073 }
2074
2075 SOAP_FMAC3 struct KMS_CA__RetrieveRootCACertificateResponse * SOAP_FMAC4 soap_in_KMS_CA__RetrieveRootCACertificateResponse(struct soap *soap, const char *tag, struct KMS_CA__RetrieveRootCACertificateResponse *a, const char *type)
2076 {
2077         size_t soap_flag_RootCACertificate = 1;
2078         size_t soap_flag_AuthenticationHashIterationCount = 1;
2079         size_t soap_flag_ClientAuthenticationChallenge = 1;
2080         if (soap_element_begin_in(soap, tag, 0, type))
2081                 return NULL;
2082         a = (struct KMS_CA__RetrieveRootCACertificateResponse *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse, sizeof(struct KMS_CA__RetrieveRootCACertificateResponse), 0, NULL, NULL, NULL);
2083         if (!a)
2084                 return NULL;
2085         soap_default_KMS_CA__RetrieveRootCACertificateResponse(soap, a);
2086         if (soap->body && !*soap->href)
2087         {
2088                 for (;;)
2089                 {       soap->error = SOAP_TAG_MISMATCH;
2090                         if (soap_flag_RootCACertificate && soap->error == SOAP_TAG_MISMATCH)
2091                                 if (soap_in_xsd__hexBinary(soap, "RootCACertificate", &a->RootCACertificate, "xsd:hexBinary"))
2092                                 {       soap_flag_RootCACertificate--;
2093                                         continue;
2094                                 }
2095                         if (soap_flag_AuthenticationHashIterationCount && soap->error == SOAP_TAG_MISMATCH)
2096                                 if (soap_in_xsd__int(soap, "AuthenticationHashIterationCount", &a->AuthenticationHashIterationCount, "xsd:int"))
2097                                 {       soap_flag_AuthenticationHashIterationCount--;
2098                                         continue;
2099                                 }
2100                         if (soap_flag_ClientAuthenticationChallenge && soap->error == SOAP_TAG_MISMATCH)
2101                                 if (soap_in_xsd__hexBinary(soap, "ClientAuthenticationChallenge", &a->ClientAuthenticationChallenge, "xsd:hexBinary"))
2102                                 {       soap_flag_ClientAuthenticationChallenge--;
2103                                         continue;
2104                                 }
2105                         if (soap->error == SOAP_TAG_MISMATCH)
2106                                 soap->error = soap_ignore_element(soap);
2107                         if (soap->error == SOAP_NO_TAG)
2108                                 break;
2109                         if (soap->error)
2110                                 return NULL;
2111                 }
2112                 if (soap_element_end_in(soap, tag))
2113                         return NULL;
2114         }
2115         else
2116         {       a = (struct KMS_CA__RetrieveRootCACertificateResponse *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse, 0, sizeof(struct KMS_CA__RetrieveRootCACertificateResponse), 0, NULL);
2117                 if (soap->body && soap_element_end_in(soap, tag))
2118                         return NULL;
2119         }
2120         if ((soap->mode & SOAP_XML_STRICT) && (soap_flag_RootCACertificate > 0 || soap_flag_AuthenticationHashIterationCount > 0 || soap_flag_ClientAuthenticationChallenge > 0))
2121         {       soap->error = SOAP_OCCURS;
2122                 return NULL;
2123         }
2124         return a;
2125 }
2126
2127 SOAP_FMAC3 int SOAP_FMAC4 soap_put_KMS_CA__RetrieveRootCACertificateResponse(struct soap *soap, const struct KMS_CA__RetrieveRootCACertificateResponse *a, const char *tag, const char *type)
2128 {
2129         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse);
2130         if (soap_out_KMS_CA__RetrieveRootCACertificateResponse(soap, tag?tag:"KMS-CA:RetrieveRootCACertificateResponse", id, a, type))
2131                 return soap->error;
2132         return soap_putindependent(soap);
2133 }
2134
2135 SOAP_FMAC3 struct KMS_CA__RetrieveRootCACertificateResponse * SOAP_FMAC4 soap_get_KMS_CA__RetrieveRootCACertificateResponse(struct soap *soap, struct KMS_CA__RetrieveRootCACertificateResponse *p, const char *tag, const char *type)
2136 {
2137         if ((p = soap_in_KMS_CA__RetrieveRootCACertificateResponse(soap, tag, p, type)))
2138                 if (soap_getindependent(soap))
2139                         return NULL;
2140         return p;
2141 }
2142
2143 SOAP_FMAC1 struct KMS_CA__RetrieveRootCACertificateResponse * SOAP_FMAC2 soap_instantiate_KMS_CA__RetrieveRootCACertificateResponse(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
2144 {
2145         (void)type; (void)arrayType; /* appease -Wall -Werror */
2146         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_KMS_CA__RetrieveRootCACertificateResponse(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
2147         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_KMS_CA__RetrieveRootCACertificateResponse, n, soap_fdelete);
2148         if (!cp)
2149                 return NULL;
2150         if (n < 0)
2151         {       cp->ptr = (void*)SOAP_NEW(struct KMS_CA__RetrieveRootCACertificateResponse);
2152                 if (size)
2153                         *size = sizeof(struct KMS_CA__RetrieveRootCACertificateResponse);
2154         }
2155         else
2156         {       cp->ptr = (void*)SOAP_NEW(struct KMS_CA__RetrieveRootCACertificateResponse[n]);
2157                 if (!cp->ptr)
2158                 {       soap->error = SOAP_EOM;
2159                         return NULL;
2160                 }
2161                 if (size)
2162                         *size = n * sizeof(struct KMS_CA__RetrieveRootCACertificateResponse);
2163         }
2164                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
2165         return (struct KMS_CA__RetrieveRootCACertificateResponse*)cp->ptr;
2166 }
2167
2168 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_KMS_CA__RetrieveRootCACertificateResponse(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
2169 {
2170         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
2171         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct KMS_CA__RetrieveRootCACertificateResponse %p -> %p\n", q, p));
2172         *(struct KMS_CA__RetrieveRootCACertificateResponse*)p = *(struct KMS_CA__RetrieveRootCACertificateResponse*)q;
2173 }
2174
2175 SOAP_FMAC3 void SOAP_FMAC4 soap_default_xsd__hexBinary(struct soap *soap, struct xsd__hexBinary *a)
2176 {
2177         (void)soap; /* appease -Wall -Werror */
2178         a->__size = 0;
2179         a->__ptr = NULL;
2180 }
2181
2182 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_xsd__hexBinary(struct soap *soap, struct xsd__hexBinary const*a)
2183 {
2184         if (a->__ptr)
2185                 soap_array_reference(soap, a, (struct soap_array*)&a->__ptr, 1, SOAP_TYPE_KMS_CA_xsd__hexBinary);
2186 }
2187
2188 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__hexBinary(struct soap *soap, const char *tag, int id, const struct xsd__hexBinary *a, const char *type)
2189 {
2190         id = soap_element_id(soap, tag, id, a, (struct soap_array*)&a->__ptr, 1, type, SOAP_TYPE_KMS_CA_xsd__hexBinary);
2191         if (id < 0)
2192                 return soap->error;
2193         if (soap_element_begin_out(soap, tag, id, type))
2194                 return soap->error;
2195         if (soap_puthex(soap, a->__ptr, a->__size))
2196                 return soap->error;
2197         return soap_element_end_out(soap, tag);
2198 }
2199
2200 SOAP_FMAC3 struct xsd__hexBinary * SOAP_FMAC4 soap_in_xsd__hexBinary(struct soap *soap, const char *tag, struct xsd__hexBinary *a, const char *type)
2201 {
2202         (void)type; /* appease -Wall -Werror */
2203         if (soap_element_begin_in(soap, tag, 1, NULL))
2204                 return NULL;
2205         if (*soap->type && soap_match_tag(soap, soap->type, type) && soap_match_tag(soap, soap->type, ":hexBinary"))
2206         {       soap->error = SOAP_TYPE;
2207                 return NULL;
2208         }
2209         a = (struct xsd__hexBinary *)soap_id_enter(soap, soap->id, a, SOAP_TYPE_KMS_CA_xsd__hexBinary, sizeof(struct xsd__hexBinary), 0, NULL, NULL, NULL);
2210         if (!a)
2211                 return NULL;
2212         soap_default_xsd__hexBinary(soap, a);
2213         if (soap->body && !*soap->href)
2214         {
2215                 a->__ptr = soap_gethex(soap, &a->__size);
2216                 if ((!a->__ptr && soap->error) || soap_element_end_in(soap, tag))
2217                         return NULL;
2218         }
2219         else
2220         {       a = (struct xsd__hexBinary *)soap_id_forward(soap, soap->href, (void*)a, 0, SOAP_TYPE_KMS_CA_xsd__hexBinary, 0, sizeof(struct xsd__hexBinary), 0, NULL);
2221                 if (soap->body && soap_element_end_in(soap, tag))
2222                         return NULL;
2223         }
2224         return a;
2225 }
2226
2227 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__hexBinary(struct soap *soap, const struct xsd__hexBinary *a, const char *tag, const char *type)
2228 {
2229         register int id = soap_embed(soap, (void*)a, (struct soap_array*)&a->__ptr, 1, tag, SOAP_TYPE_KMS_CA_xsd__hexBinary);
2230         if (soap_out_xsd__hexBinary(soap, tag?tag:"SOAP-ENC:Array", id, a, type))
2231                 return soap->error;
2232         return soap_putindependent(soap);
2233 }
2234
2235 SOAP_FMAC3 struct xsd__hexBinary * SOAP_FMAC4 soap_get_xsd__hexBinary(struct soap *soap, struct xsd__hexBinary *p, const char *tag, const char *type)
2236 {
2237         if ((p = soap_in_xsd__hexBinary(soap, tag, p, type)))
2238                 if (soap_getindependent(soap))
2239                         return NULL;
2240         return p;
2241 }
2242
2243 SOAP_FMAC1 struct xsd__hexBinary * SOAP_FMAC2 soap_instantiate_xsd__hexBinary(struct soap *soap, int n, const char *type, const char *arrayType, size_t *size)
2244 {
2245         (void)type; (void)arrayType; /* appease -Wall -Werror */
2246         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "soap_instantiate_xsd__hexBinary(%d, %s, %s)\n", n, type?type:"", arrayType?arrayType:""));
2247         struct soap_clist *cp = soap_link(soap, NULL, SOAP_TYPE_KMS_CA_xsd__hexBinary, n, soap_fdelete);
2248         if (!cp)
2249                 return NULL;
2250         if (n < 0)
2251         {       cp->ptr = (void*)SOAP_NEW(struct xsd__hexBinary);
2252                 if (size)
2253                         *size = sizeof(struct xsd__hexBinary);
2254         }
2255         else
2256         {       cp->ptr = (void*)SOAP_NEW(struct xsd__hexBinary[n]);
2257                 if (!cp->ptr)
2258                 {       soap->error = SOAP_EOM;
2259                         return NULL;
2260                 }
2261                 if (size)
2262                         *size = n * sizeof(struct xsd__hexBinary);
2263         }
2264                 DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Instantiated location=%p\n", cp->ptr));
2265         return (struct xsd__hexBinary*)cp->ptr;
2266 }
2267
2268 SOAP_FMAC3 void SOAP_FMAC4 soap_copy_xsd__hexBinary(struct soap *soap, int st, int tt, void *p, size_t len, const void *q, size_t n)
2269 {
2270         (void)soap; (void)st; (void)len; (void)n; /* appease -Wall -Werror */
2271         DBGLOG(TEST, SOAP_MESSAGE(fdebug, "Copying struct xsd__hexBinary %p -> %p\n", q, p));
2272         *(struct xsd__hexBinary*)p = *(struct xsd__hexBinary*)q;
2273 }
2274
2275 #ifndef WITH_NOGLOBAL
2276
2277 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a)
2278 {
2279         if (!soap_reference(soap, *a, SOAP_TYPE_KMS_CA_SOAP_ENV__Reason))
2280                 soap_serialize_SOAP_ENV__Reason(soap, *a);
2281 }
2282
2283 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Reason *const*a, const char *type)
2284 {
2285         id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_KMS_CA_SOAP_ENV__Reason);
2286         if (id < 0)
2287                 return soap->error;
2288         return soap_out_SOAP_ENV__Reason(soap, tag, id, *a, type);
2289 }
2290
2291 SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Reason(struct soap *soap, const char *tag, struct SOAP_ENV__Reason **a, const char *type)
2292 {
2293         if (soap_element_begin_in(soap, tag, 1, NULL))
2294                 return NULL;
2295         if (!a)
2296                 if (!(a = (struct SOAP_ENV__Reason **)soap_malloc(soap, sizeof(struct SOAP_ENV__Reason *))))
2297                         return NULL;
2298         *a = NULL;
2299         if (!soap->null && *soap->href != '#')
2300         {       soap_revert(soap);
2301                 if (!(*a = soap_in_SOAP_ENV__Reason(soap, tag, *a, type)))
2302                         return NULL;
2303         }
2304         else
2305         {       a = (struct SOAP_ENV__Reason **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_KMS_CA_SOAP_ENV__Reason, sizeof(struct SOAP_ENV__Reason), 0);
2306                 if (soap->body && soap_element_end_in(soap, tag))
2307                         return NULL;
2308         }
2309         return a;
2310 }
2311
2312 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason *const*a, const char *tag, const char *type)
2313 {
2314         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_PointerToSOAP_ENV__Reason);
2315         if (soap_out_PointerToSOAP_ENV__Reason(soap, tag?tag:"SOAP-ENV:Reason", id, a, type))
2316                 return soap->error;
2317         return soap_putindependent(soap);
2318 }
2319
2320 SOAP_FMAC3 struct SOAP_ENV__Reason ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Reason(struct soap *soap, struct SOAP_ENV__Reason **p, const char *tag, const char *type)
2321 {
2322         if ((p = soap_in_PointerToSOAP_ENV__Reason(soap, tag, p, type)))
2323                 if (soap_getindependent(soap))
2324                         return NULL;
2325         return p;
2326 }
2327
2328 #endif
2329
2330 #ifndef WITH_NOGLOBAL
2331
2332 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a)
2333 {
2334         if (!soap_reference(soap, *a, SOAP_TYPE_KMS_CA_SOAP_ENV__Detail))
2335                 soap_serialize_SOAP_ENV__Detail(soap, *a);
2336 }
2337
2338 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Detail *const*a, const char *type)
2339 {
2340         id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_KMS_CA_SOAP_ENV__Detail);
2341         if (id < 0)
2342                 return soap->error;
2343         return soap_out_SOAP_ENV__Detail(soap, tag, id, *a, type);
2344 }
2345
2346 SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Detail(struct soap *soap, const char *tag, struct SOAP_ENV__Detail **a, const char *type)
2347 {
2348         if (soap_element_begin_in(soap, tag, 1, NULL))
2349                 return NULL;
2350         if (!a)
2351                 if (!(a = (struct SOAP_ENV__Detail **)soap_malloc(soap, sizeof(struct SOAP_ENV__Detail *))))
2352                         return NULL;
2353         *a = NULL;
2354         if (!soap->null && *soap->href != '#')
2355         {       soap_revert(soap);
2356                 if (!(*a = soap_in_SOAP_ENV__Detail(soap, tag, *a, type)))
2357                         return NULL;
2358         }
2359         else
2360         {       a = (struct SOAP_ENV__Detail **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_KMS_CA_SOAP_ENV__Detail, sizeof(struct SOAP_ENV__Detail), 0);
2361                 if (soap->body && soap_element_end_in(soap, tag))
2362                         return NULL;
2363         }
2364         return a;
2365 }
2366
2367 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail *const*a, const char *tag, const char *type)
2368 {
2369         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_PointerToSOAP_ENV__Detail);
2370         if (soap_out_PointerToSOAP_ENV__Detail(soap, tag?tag:"SOAP-ENV:Detail", id, a, type))
2371                 return soap->error;
2372         return soap_putindependent(soap);
2373 }
2374
2375 SOAP_FMAC3 struct SOAP_ENV__Detail ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Detail(struct soap *soap, struct SOAP_ENV__Detail **p, const char *tag, const char *type)
2376 {
2377         if ((p = soap_in_PointerToSOAP_ENV__Detail(soap, tag, p, type)))
2378                 if (soap_getindependent(soap))
2379                         return NULL;
2380         return p;
2381 }
2382
2383 #endif
2384
2385 #ifndef WITH_NOGLOBAL
2386
2387 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a)
2388 {
2389         if (!soap_reference(soap, *a, SOAP_TYPE_KMS_CA_SOAP_ENV__Code))
2390                 soap_serialize_SOAP_ENV__Code(soap, *a);
2391 }
2392
2393 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, int id, struct SOAP_ENV__Code *const*a, const char *type)
2394 {
2395         id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_KMS_CA_SOAP_ENV__Code);
2396         if (id < 0)
2397                 return soap->error;
2398         return soap_out_SOAP_ENV__Code(soap, tag, id, *a, type);
2399 }
2400
2401 SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_in_PointerToSOAP_ENV__Code(struct soap *soap, const char *tag, struct SOAP_ENV__Code **a, const char *type)
2402 {
2403         if (soap_element_begin_in(soap, tag, 1, NULL))
2404                 return NULL;
2405         if (!a)
2406                 if (!(a = (struct SOAP_ENV__Code **)soap_malloc(soap, sizeof(struct SOAP_ENV__Code *))))
2407                         return NULL;
2408         *a = NULL;
2409         if (!soap->null && *soap->href != '#')
2410         {       soap_revert(soap);
2411                 if (!(*a = soap_in_SOAP_ENV__Code(soap, tag, *a, type)))
2412                         return NULL;
2413         }
2414         else
2415         {       a = (struct SOAP_ENV__Code **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_KMS_CA_SOAP_ENV__Code, sizeof(struct SOAP_ENV__Code), 0);
2416                 if (soap->body && soap_element_end_in(soap, tag))
2417                         return NULL;
2418         }
2419         return a;
2420 }
2421
2422 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code *const*a, const char *tag, const char *type)
2423 {
2424         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_PointerToSOAP_ENV__Code);
2425         if (soap_out_PointerToSOAP_ENV__Code(soap, tag?tag:"SOAP-ENV:Code", id, a, type))
2426                 return soap->error;
2427         return soap_putindependent(soap);
2428 }
2429
2430 SOAP_FMAC3 struct SOAP_ENV__Code ** SOAP_FMAC4 soap_get_PointerToSOAP_ENV__Code(struct soap *soap, struct SOAP_ENV__Code **p, const char *tag, const char *type)
2431 {
2432         if ((p = soap_in_PointerToSOAP_ENV__Code(soap, tag, p, type)))
2433                 if (soap_getindependent(soap))
2434                         return NULL;
2435         return p;
2436 }
2437
2438 #endif
2439
2440 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_PointerTounsignedByte(struct soap *soap, unsigned char *const*a)
2441 {
2442         soap_reference(soap, *a, SOAP_TYPE_KMS_CA_unsignedByte);
2443 }
2444
2445 SOAP_FMAC3 int SOAP_FMAC4 soap_out_PointerTounsignedByte(struct soap *soap, const char *tag, int id, unsigned char *const*a, const char *type)
2446 {
2447         id = soap_element_id(soap, tag, id, *a, NULL, 0, type, SOAP_TYPE_KMS_CA_unsignedByte);
2448         if (id < 0)
2449                 return soap->error;
2450         return soap_out_unsignedByte(soap, tag, id, *a, type);
2451 }
2452
2453 SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_in_PointerTounsignedByte(struct soap *soap, const char *tag, unsigned char **a, const char *type)
2454 {
2455         if (soap_element_begin_in(soap, tag, 1, NULL))
2456                 return NULL;
2457         if (!a)
2458                 if (!(a = (unsigned char **)soap_malloc(soap, sizeof(unsigned char *))))
2459                         return NULL;
2460         *a = NULL;
2461         if (!soap->null && *soap->href != '#')
2462         {       soap_revert(soap);
2463                 if (!(*a = soap_in_unsignedByte(soap, tag, *a, type)))
2464                         return NULL;
2465         }
2466         else
2467         {       a = (unsigned char **)soap_id_lookup(soap, soap->href, (void**)a, SOAP_TYPE_KMS_CA_unsignedByte, sizeof(unsigned char), 0);
2468                 if (soap->body && soap_element_end_in(soap, tag))
2469                         return NULL;
2470         }
2471         return a;
2472 }
2473
2474 SOAP_FMAC3 int SOAP_FMAC4 soap_put_PointerTounsignedByte(struct soap *soap, unsigned char *const*a, const char *tag, const char *type)
2475 {
2476         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_PointerTounsignedByte);
2477         if (soap_out_PointerTounsignedByte(soap, tag?tag:"unsignedByte", id, a, type))
2478                 return soap->error;
2479         return soap_putindependent(soap);
2480 }
2481
2482 SOAP_FMAC3 unsigned char ** SOAP_FMAC4 soap_get_PointerTounsignedByte(struct soap *soap, unsigned char **p, const char *tag, const char *type)
2483 {
2484         if ((p = soap_in_PointerTounsignedByte(soap, tag, p, type)))
2485                 if (soap_getindependent(soap))
2486                         return NULL;
2487         return p;
2488 }
2489
2490 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__duration(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
2491 {
2492         return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_xsd__duration);
2493 }
2494
2495 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_xsd__duration(struct soap *soap, const char *tag, char **a, const char *type)
2496 {       char **p;
2497         p = soap_instring(soap, tag, a, type, SOAP_TYPE_KMS_CA_xsd__duration, 1, -1, -1);
2498         return p;
2499 }
2500
2501 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__duration(struct soap *soap, char *const*a, const char *tag, const char *type)
2502 {
2503         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_xsd__duration);
2504         if (soap_out_xsd__duration(soap, tag?tag:"byte", id, a, type))
2505                 return soap->error;
2506         return soap_putindependent(soap);
2507 }
2508
2509 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_xsd__duration(struct soap *soap, char **p, const char *tag, const char *type)
2510 {
2511         if ((p = soap_in_xsd__duration(soap, tag, p, type)))
2512                 if (soap_getindependent(soap))
2513                         return NULL;
2514         return p;
2515 }
2516
2517 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__dateTime(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
2518 {
2519         return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_xsd__dateTime);
2520 }
2521
2522 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_xsd__dateTime(struct soap *soap, const char *tag, char **a, const char *type)
2523 {       char **p;
2524         p = soap_instring(soap, tag, a, type, SOAP_TYPE_KMS_CA_xsd__dateTime, 1, -1, -1);
2525         return p;
2526 }
2527
2528 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__dateTime(struct soap *soap, char *const*a, const char *tag, const char *type)
2529 {
2530         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_xsd__dateTime);
2531         if (soap_out_xsd__dateTime(soap, tag?tag:"byte", id, a, type))
2532                 return soap->error;
2533         return soap_putindependent(soap);
2534 }
2535
2536 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_xsd__dateTime(struct soap *soap, char **p, const char *tag, const char *type)
2537 {
2538         if ((p = soap_in_xsd__dateTime(soap, tag, p, type)))
2539                 if (soap_getindependent(soap))
2540                         return NULL;
2541         return p;
2542 }
2543
2544 SOAP_FMAC3 int SOAP_FMAC4 soap_out_xsd__string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
2545 {
2546         return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_xsd__string);
2547 }
2548
2549 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_xsd__string(struct soap *soap, const char *tag, char **a, const char *type)
2550 {       char **p;
2551         p = soap_instring(soap, tag, a, type, SOAP_TYPE_KMS_CA_xsd__string, 1, -1, -1);
2552         return p;
2553 }
2554
2555 SOAP_FMAC3 int SOAP_FMAC4 soap_put_xsd__string(struct soap *soap, char *const*a, const char *tag, const char *type)
2556 {
2557         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_xsd__string);
2558         if (soap_out_xsd__string(soap, tag?tag:"byte", id, a, type))
2559                 return soap->error;
2560         return soap_putindependent(soap);
2561 }
2562
2563 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_xsd__string(struct soap *soap, char **p, const char *tag, const char *type)
2564 {
2565         if ((p = soap_in_xsd__string(soap, tag, p, type)))
2566                 if (soap_getindependent(soap))
2567                         return NULL;
2568         return p;
2569 }
2570
2571 SOAP_FMAC3 int SOAP_FMAC4 soap_out__QName(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
2572 {
2573         return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_KMS_CA__QName);
2574 }
2575
2576 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in__QName(struct soap *soap, const char *tag, char **a, const char *type)
2577 {       char **p;
2578         p = soap_instring(soap, tag, a, type, SOAP_TYPE_KMS_CA__QName, 2, -1, -1);
2579         return p;
2580 }
2581
2582 SOAP_FMAC3 int SOAP_FMAC4 soap_put__QName(struct soap *soap, char *const*a, const char *tag, const char *type)
2583 {
2584         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA__QName);
2585         if (soap_out__QName(soap, tag?tag:"byte", id, a, type))
2586                 return soap->error;
2587         return soap_putindependent(soap);
2588 }
2589
2590 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get__QName(struct soap *soap, char **p, const char *tag, const char *type)
2591 {
2592         if ((p = soap_in__QName(soap, tag, p, type)))
2593                 if (soap_getindependent(soap))
2594                         return NULL;
2595         return p;
2596 }
2597
2598 SOAP_FMAC3 void SOAP_FMAC4 soap_default_string(struct soap *soap, char **a)
2599 {
2600         (void)soap; /* appease -Wall -Werror */
2601 #ifdef SOAP_DEFAULT_string
2602         *a = SOAP_DEFAULT_string;
2603 #else
2604         *a = (char *)0;
2605 #endif
2606 }
2607
2608 SOAP_FMAC3 void SOAP_FMAC4 soap_serialize_string(struct soap *soap, char *const*a)
2609 {
2610         soap_reference(soap, *a, SOAP_TYPE_KMS_CA_string);
2611 }
2612
2613 SOAP_FMAC3 int SOAP_FMAC4 soap_out_string(struct soap *soap, const char *tag, int id, char *const*a, const char *type)
2614 {
2615         return soap_outstring(soap, tag, id, a, type, SOAP_TYPE_KMS_CA_string);
2616 }
2617
2618 SOAP_FMAC3 char * * SOAP_FMAC4 soap_in_string(struct soap *soap, const char *tag, char **a, const char *type)
2619 {       char **p;
2620         p = soap_instring(soap, tag, a, type, SOAP_TYPE_KMS_CA_string, 1, -1, -1);
2621         return p;
2622 }
2623
2624 SOAP_FMAC3 int SOAP_FMAC4 soap_put_string(struct soap *soap, char *const*a, const char *tag, const char *type)
2625 {
2626         register int id = soap_embed(soap, (void*)a, NULL, 0, tag, SOAP_TYPE_KMS_CA_string);
2627         if (soap_out_string(soap, tag?tag:"byte", id, a, type))
2628                 return soap->error;
2629         return soap_putindependent(soap);
2630 }
2631
2632 SOAP_FMAC3 char ** SOAP_FMAC4 soap_get_string(struct soap *soap, char **p, const char *tag, const char *type)
2633 {
2634         if ((p = soap_in_string(soap, tag, p, type)))
2635                 if (soap_getindependent(soap))
2636                         return NULL;
2637         return p;
2638 }
2639
2640 } // namespace KMS_CA
2641
2642
2643 #if defined(__BORLANDC__)
2644 #pragma option pop
2645 #pragma option pop
2646 #endif
2647
2648 /* End of KMS_CAC.cpp */