1		/*
2		* Copyright 1999-2006 University of Chicago
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17
18		/*
19		* This file is automatically generated by the Globus WSDLtoC converter
20		*/
21
22		#include "xsd_QName.h"
23		#include "globus_soap_message.h"
24		#include "globus_xsd_type_info.h"
25		#include "ds_X509DataType.h"
26
27		xsd_QName ds_X509DataType_choice_qname =
28		{
29		"http://www.w3.org/2000/09/xmldsig#",
30		"X509DataType_choice"
31		};
32
33		globus_result_t
34		ds_X509DataType_choice_serialize_wrapper(
35		const xsd_QName *                   element_qname,
36		const void *                        instance,
37		globus_soap_message_handle_t        message_handle,
38		globus_xsd_element_options_t        options)
39	0	{
40	0	return ds_X509DataType_choice_serialize(
41		element_qname,
42		(ds_X509DataType_choice *) instance,
43		message_handle, options);
44		}
45
46		globus_result_t
47		ds_X509DataType_choice_deserialize_pointer_wrapper(
48		const xsd_QName *                   element_qname,
49		void **                             ip,
50		globus_soap_message_handle_t        message_handle,
51		globus_xsd_element_options_t        options)
52	0	{
53	0	return ds_X509DataType_choice_deserialize_pointer(
54		element_qname,
55		(ds_X509DataType_choice **) ip,
56		message_handle, options);
57		}
58
59		globus_result_t
60		ds_X509DataType_choice_init_wrapper(void **object)
61	0	{
62	0	return ds_X509DataType_choice_init(
63		(ds_X509DataType_choice **) object);
64		}
65
66		void
67		ds_X509DataType_choice_destroy_wrapper(
68		void *                          object)
69	0	{
70	0	ds_X509DataType_choice_destroy(
71		(ds_X509DataType_choice *) object);
72		}
73
74		globus_result_t
75		ds_X509DataType_choice_copy_wrapper(
76		void **                         dest_obj,
77		const void *                    src_obj)
78	0	{
79	0	return ds_X509DataType_choice_copy(
80		(ds_X509DataType_choice **) dest_obj,
81		(ds_X509DataType_choice *) src_obj);
82		}
83
84		globus_result_t
85		ds_X509DataType_choice_init_contents_wrapper(void *object)
86	0	{
87	0	return ds_X509DataType_choice_init_contents(
88		(ds_X509DataType_choice *) object);
89		}
90
91		void
92		ds_X509DataType_choice_destroy_contents_wrapper(
93		void *                          object)
94	0	{
95	0	ds_X509DataType_choice_destroy_contents(
96		(ds_X509DataType_choice *) object);
97		}
98
99		globus_result_t
100		ds_X509DataType_choice_copy_contents_wrapper(
101		void *                          dest_obj,
102		const void *                    src_obj)
103	0	{
104	0	return ds_X509DataType_choice_copy_contents(
105		(ds_X509DataType_choice *) dest_obj,
106		(ds_X509DataType_choice *) src_obj);
107		}
108
109		globus_result_t
110		ds_X509DataType_choice_serialize_contents_wrapper(
111		const xsd_QName *                   element_qname,
112		const void *                        instance,
113		globus_soap_message_handle_t        message_handle,
114		globus_xsd_element_options_t        options)
115	0	{
116	0	return ds_X509DataType_choice_serialize_contents(
117		element_qname,
118		(const ds_X509DataType_choice *) instance,
119		message_handle, options);
120		}
121
122		globus_result_t
123		ds_X509DataType_choice_deserialize_contents_wrapper(
124		const xsd_QName *                   element_qname,
125		void **                             instance,
126		globus_soap_message_handle_t        message_handle,
127		globus_xsd_element_options_t        options)
128	0	{
129	0	globus_result_t                     result;
130	0	GlobusFuncName(ds_X509DataType_choice_deserialize_contents_wrapper);
131	0	GlobusSoapMessageDebugEnter();
132
133	0	if(!*instance)
134		{
135	0	result = ds_X509DataType_choice_init(
136		(ds_X509DataType_choice **)instance);
137	0	if(result != GLOBUS_SUCCESS)
138		{
139	0	goto error;
140		}
141		}
142
143	0	result = ds_X509DataType_choice_deserialize_contents(
144		element_qname,
145		*(ds_X509DataType_choice **)instance,
146		message_handle, options);
147		error:
148	0	GlobusSoapMessageDebugExit();
149	0	return result;
150		}
151
152		globus_result_t
153		ds_X509DataType_choice_array_serialize_wrapper(
154		const xsd_QName *               element,
155		const void *                    instance,
156		globus_soap_message_handle_t    message,
157		globus_xsd_element_options_t    options)
158	0	{
159	0	return ds_X509DataType_choice_array_serialize(
160		element,
161		(ds_X509DataType_choice_array *) instance,
162		message, options);
163		}
164
165		globus_result_t
166		ds_X509DataType_choice_array_deserialize_wrapper(
167		const xsd_QName *                   element_qname,
168		void **                             inst,
169		globus_soap_message_handle_t        message,
170		globus_xsd_element_options_t        options)
171	0	{
172	0	if(!*inst)
173		{
174	0	globus_result_t                 result;
175
176	0	result = ds_X509DataType_choice_array_init(
177		(ds_X509DataType_choice_array **)inst);
178	0	if(result != GLOBUS_SUCCESS)
179		{
180	0	return result;
181		}
182		}
183
184	0	return ds_X509DataType_choice_array_deserialize(
185		element_qname,
186		*(ds_X509DataType_choice_array **) inst,
187		message, options);
188		}
189
190		globus_result_t
191		ds_X509DataType_choice_array_init_wrapper(
192		void **                             arr)
193	0	{
194	0	return ds_X509DataType_choice_array_init(
195		(ds_X509DataType_choice_array **) arr);
196		}
197
198		void
199		ds_X509DataType_choice_array_destroy_wrapper(
200		void *                              arr)
201	0	{
202	0	ds_X509DataType_choice_array_destroy(
203		(ds_X509DataType_choice_array *) arr);
204		}
205
206		globus_result_t
207		ds_X509DataType_choice_array_copy_wrapper(
208		void **                             dest_arr,
209		const void *                        src_arr)
210	0	{
211	0	return ds_X509DataType_choice_array_copy(
212		(ds_X509DataType_choice_array **) dest_arr,
213		(const ds_X509DataType_choice_array *) src_arr);
214		}
215
216		globus_result_t
217		ds_X509DataType_choice_array_init_contents_wrapper(
218		void *                              arr)
219	0	{
220	0	return ds_X509DataType_choice_array_init_contents(
221		(ds_X509DataType_choice_array *) arr);
222		}
223
224		void
225		ds_X509DataType_choice_array_destroy_contents_wrapper(
226		void *                              arr)
227	0	{
228	0	ds_X509DataType_choice_array_destroy_contents(
229		(ds_X509DataType_choice_array *) arr);
230		}
231
232		globus_result_t
233		ds_X509DataType_choice_array_copy_contents_wrapper(
234		void *                              dest_arr,
235		const void *                        src_arr)
236	0	{
237	0	return ds_X509DataType_choice_array_copy_contents(
238		(ds_X509DataType_choice_array *) dest_arr,
239		(const ds_X509DataType_choice_array *) src_arr);
240		}
241
242		struct globus_xsd_type_info_s ds_X509DataType_choice_array_info =
243		{
244		&ds_X509DataType_choice_qname,
245		ds_X509DataType_choice_array_serialize_wrapper,
246		ds_X509DataType_choice_array_deserialize_wrapper,
247		ds_X509DataType_choice_array_init_wrapper,
248		ds_X509DataType_choice_array_destroy_wrapper,
249		ds_X509DataType_choice_array_copy_wrapper,
250		ds_X509DataType_choice_array_init_contents_wrapper,
251		ds_X509DataType_choice_array_destroy_contents_wrapper,
252		ds_X509DataType_choice_array_copy_contents_wrapper,
253		sizeof(ds_X509DataType_choice),
254		ds_X509DataType_choice_array_push_wrapper,
255		NULL,
256		NULL
257		};
258
259		struct globus_xsd_type_info_s ds_X509DataType_choice_contents_info =
260		{
261		&ds_X509DataType_choice_qname,
262		ds_X509DataType_choice_serialize_contents_wrapper,
263		ds_X509DataType_choice_deserialize_contents_wrapper,
264		ds_X509DataType_choice_init_wrapper,
265		ds_X509DataType_choice_destroy_wrapper,
266		ds_X509DataType_choice_copy_wrapper,
267		ds_X509DataType_choice_init_contents_wrapper,
268		ds_X509DataType_choice_destroy_contents_wrapper,
269		ds_X509DataType_choice_copy_contents_wrapper,
270		sizeof(ds_X509DataType_choice),
271		NULL,
272		NULL,
273		NULL
274		};
275
276		struct globus_xsd_type_info_s ds_X509DataType_choice_info =
277		{
278		&ds_X509DataType_choice_qname,
279		ds_X509DataType_choice_serialize_wrapper,
280		ds_X509DataType_choice_deserialize_pointer_wrapper,
281		ds_X509DataType_choice_init_wrapper,
282		ds_X509DataType_choice_destroy_wrapper,
283		ds_X509DataType_choice_copy_wrapper,
284		ds_X509DataType_choice_init_contents_wrapper,
285		ds_X509DataType_choice_destroy_contents_wrapper,
286		ds_X509DataType_choice_copy_contents_wrapper,
287		sizeof(ds_X509DataType_choice),
288		NULL,
289		&ds_X509DataType_choice_contents_info,
290		&ds_X509DataType_choice_array_info
291		};
292
293		globus_result_t
294		ds_X509DataType_choice_init_contents(
295		ds_X509DataType_choice *                    instance)
296	0	{
297	0	globus_result_t                     result = GLOBUS_SUCCESS;
298	0	GlobusFuncName(ds_X509DataType_choice_init_contents);
299	0	GlobusSoapMessageDebugEnter();
300
301	0	memset(instance, 0, sizeof(ds_X509DataType));
302
303	0	GlobusSoapMessageDebugExit();
304	0	return result;
305		}
306
307		globus_result_t
308		ds_X509DataType_choice_init(
309		ds_X509DataType_choice ** object)
310	0	{
311	0	ds_X509DataType_choice * instance;
312	0	globus_result_t                     result = GLOBUS_SUCCESS;
313	0	GlobusFuncName(ds_X509DataType_choice_init);
314	0	GlobusSoapMessageDebugEnter();
315
316	0	instance = globus_malloc(sizeof(ds_X509DataType_choice));
317	0	if(!instance)
318		{
319	0	result = GlobusSoapMessageErrorOutOfMemory;
320	0	goto exit;
321		}
322
323	0	memset(instance, 0, sizeof(ds_X509DataType_choice));
324
325	0	*object = instance;
326
327		exit:
328	0	GlobusSoapMessageDebugExit();
329	0	return result;
330		}
331
332		void
333		ds_X509DataType_choice_destroy(
334		ds_X509DataType_choice * instance)
335	0	{
336	0	GlobusFuncName(ds_X509DataType_choice_destroy);
337	0	GlobusSoapMessageDebugEnter();
338
339	0	if(!instance)
340		{
341	0	goto exit;
342		}
343
344	0	ds_X509DataType_choice_destroy_contents(instance);
345	0	free(instance);
346
347		exit:
348
349	0	GlobusSoapMessageDebugExit();
350		}
351
352
353
354		void
355		ds_X509DataType_choice_destroy_contents(
356		ds_X509DataType_choice * instance)
357	0	{
358	0	GlobusFuncName(ds_X509DataType_choice_destroy_contents);
359	0	GlobusSoapMessageDebugEnter();
360
361	0	switch(instance->type)
362		{
363
364		case ds_X509DataType_X509IssuerSerial:
365
366	0	ds_X509IssuerSerialType_destroy_contents(
367		&instance->value.X509IssuerSerial);
368	0	break;
369
370		case ds_X509DataType_X509SKI:
371
372	0	xsd_base64Binary_destroy_contents(
373		&instance->value.X509SKI);
374	0	break;
375
376		case ds_X509DataType_X509SubjectName:
377
378	0	xsd_string_destroy_contents(
379		&instance->value.X509SubjectName);
380	0	break;
381
382		case ds_X509DataType_X509Certificate:
383
384	0	xsd_base64Binary_destroy_contents(
385		&instance->value.X509Certificate);
386	0	break;
387
388		case ds_X509DataType_X509CRL:
389
390	0	xsd_base64Binary_destroy_contents(
391		&instance->value.X509CRL);
392	0	break;
393
394		case ds_X509DataType_any:
395
396	0	xsd_any_destroy_contents(
397		&instance->value.any);
398		break;
399
400		default:
401	0	break;
402		}
403
404	0	instance->type = ds_X509DataType_undefined;
405
406	0	GlobusSoapMessageDebugExit();
407		}
408
409		globus_result_t
410		ds_X509DataType_choice_copy(
411		ds_X509DataType_choice ** dest_obj,
412		const ds_X509DataType_choice * src_obj)
413	0	{
414	0	globus_result_t                     result = GLOBUS_SUCCESS;
415	0	ds_X509DataType_choice * instance;
416	0	GlobusFuncName(ds_X509DataType_choice_copy);
417
418	0	GlobusSoapMessageDebugEnter();
419
420	0	instance = malloc(sizeof(ds_X509DataType_choice));
421	0	if (instance == NULL)
422		{
423	0	GlobusSoapMessageDebugExit();
424	0	return GlobusSoapMessageErrorOutOfMemory;
425		}
426
427	0	result = ds_X509DataType_choice_copy_contents(instance, src_obj);
428	0	if(result != GLOBUS_SUCCESS)
429		{
430	0	globus_free(instance);
431	0	GlobusSoapMessageDebugExit();
432	0	return GlobusSoapMessageErrorOutOfMemory;
433		}
434
435	0	*dest_obj = instance;
436	0	GlobusSoapMessageDebugExit();
437	0	return result;
438		}
439
440
441
442		globus_result_t
443		ds_X509DataType_choice_copy_contents(
444		ds_X509DataType_choice * instance,
445		const ds_X509DataType_choice * src_obj)
446	0	{
447	0	xsd_QName                           subelement;
448	0	globus_result_t                     result = GLOBUS_SUCCESS;
449	0	GlobusFuncName(ds_X509DataType_choice_copy_contents);
450
451	0	GlobusSoapMessageDebugEnter();
452
453	0	switch(src_obj->type)
454		{
455
456		case ds_X509DataType_X509IssuerSerial:
457	0	instance->type = ds_X509DataType_X509IssuerSerial;
458	0	result = ds_X509IssuerSerialType_copy_contents(
459		&instance->value.X509IssuerSerial,
460		&src_obj->value.X509IssuerSerial);
461	0	if(result != GLOBUS_SUCCESS)
462		{
463	0	result = GlobusSoapMessageErrorSerializeFailed(
464		result, NULL, &ds_X509DataType_choice_qname);
465	0	goto exit;
466		}
467
468	0	break;
469
470		case ds_X509DataType_X509SKI:
471	0	instance->type = ds_X509DataType_X509SKI;
472	0	result = xsd_base64Binary_copy_contents(
473		&instance->value.X509SKI,
474		&src_obj->value.X509SKI);
475	0	if(result != GLOBUS_SUCCESS)
476		{
477	0	result = GlobusSoapMessageErrorSerializeFailed(
478		result, NULL, &ds_X509DataType_choice_qname);
479	0	goto exit;
480		}
481
482	0	break;
483
484		case ds_X509DataType_X509SubjectName:
485	0	instance->type = ds_X509DataType_X509SubjectName;
486	0	result = xsd_string_copy_contents(
487		&instance->value.X509SubjectName,
488		&src_obj->value.X509SubjectName);
489	0	if(result != GLOBUS_SUCCESS)
490		{
491	0	result = GlobusSoapMessageErrorSerializeFailed(
492		result, NULL, &ds_X509DataType_choice_qname);
493	0	goto exit;
494		}
495
496	0	break;
497
498		case ds_X509DataType_X509Certificate:
499	0	instance->type = ds_X509DataType_X509Certificate;
500	0	result = xsd_base64Binary_copy_contents(
501		&instance->value.X509Certificate,
502		&src_obj->value.X509Certificate);
503	0	if(result != GLOBUS_SUCCESS)
504		{
505	0	result = GlobusSoapMessageErrorSerializeFailed(
506		result, NULL, &ds_X509DataType_choice_qname);
507	0	goto exit;
508		}
509
510	0	break;
511
512		case ds_X509DataType_X509CRL:
513	0	instance->type = ds_X509DataType_X509CRL;
514	0	result = xsd_base64Binary_copy_contents(
515		&instance->value.X509CRL,
516		&src_obj->value.X509CRL);
517	0	if(result != GLOBUS_SUCCESS)
518		{
519	0	result = GlobusSoapMessageErrorSerializeFailed(
520		result, NULL, &ds_X509DataType_choice_qname);
521	0	goto exit;
522		}
523
524	0	break;
525
526		case ds_X509DataType_any:
527	0	instance->type = ds_X509DataType_any;
528	0	result = xsd_any_copy_contents(
529		&instance->value.any,
530		&src_obj->value.any);
531	0	if(result != GLOBUS_SUCCESS)
532		{
533	0	result = GlobusSoapMessageErrorSerializeFailed(
534		result, NULL, &ds_X509DataType_choice_qname);
535		goto exit;
536		}
537
538	0	break;
539
540		default:
541	0	break;
542		}
543
544		exit:
545
546	0	GlobusSoapMessageDebugExit();
547	0	return result;
548		}
549
550
551
552
553
554		globus_result_t
555		ds_X509DataType_choice_serialize_contents(
556		const xsd_QName *                   element_qname, /* ignored */
557		const ds_X509DataType_choice *       instance,
558		globus_soap_message_handle_t        message_handle,
559		globus_xsd_element_options_t        options)
560	0	{
561	0	xsd_QName                           subelement;
562	0	globus_result_t                     result = GLOBUS_SUCCESS;
563	0	GlobusFuncName(ds_X509DataType_choice_serialize_contents);
564	0	GlobusSoapMessageDebugEnter();
565
566	0	switch(instance->type)
567		{
568
569		case ds_X509DataType_X509IssuerSerial:
570
571	0	subelement.local = "X509IssuerSerial";
572	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
573	0	result = ds_X509IssuerSerialType_serialize(
574		&subelement,
575		&instance->value.X509IssuerSerial,
576		message_handle,
577		options);
578	0	if(result != GLOBUS_SUCCESS)
579		{
580	0	result = GlobusSoapMessageErrorSerializeFailed(
581		result, NULL, &ds_X509DataType_choice_qname);
582	0	goto exit;
583		}
584
585	0	break;
586
587		case ds_X509DataType_X509SKI:
588
589	0	subelement.local = "X509SKI";
590	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
591	0	result = xsd_base64Binary_serialize(
592		&subelement,
593		&instance->value.X509SKI,
594		message_handle,
595		options);
596	0	if(result != GLOBUS_SUCCESS)
597		{
598	0	result = GlobusSoapMessageErrorSerializeFailed(
599		result, NULL, &ds_X509DataType_choice_qname);
600	0	goto exit;
601		}
602
603	0	break;
604
605		case ds_X509DataType_X509SubjectName:
606
607	0	subelement.local = "X509SubjectName";
608	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
609	0	result = xsd_string_serialize(
610		&subelement,
611		&instance->value.X509SubjectName,
612		message_handle,
613		options);
614	0	if(result != GLOBUS_SUCCESS)
615		{
616	0	result = GlobusSoapMessageErrorSerializeFailed(
617		result, NULL, &ds_X509DataType_choice_qname);
618	0	goto exit;
619		}
620
621	0	break;
622
623		case ds_X509DataType_X509Certificate:
624
625	0	subelement.local = "X509Certificate";
626	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
627	0	result = xsd_base64Binary_serialize(
628		&subelement,
629		&instance->value.X509Certificate,
630		message_handle,
631		options);
632	0	if(result != GLOBUS_SUCCESS)
633		{
634	0	result = GlobusSoapMessageErrorSerializeFailed(
635		result, NULL, &ds_X509DataType_choice_qname);
636	0	goto exit;
637		}
638
639	0	break;
640
641		case ds_X509DataType_X509CRL:
642
643	0	subelement.local = "X509CRL";
644	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
645	0	result = xsd_base64Binary_serialize(
646		&subelement,
647		&instance->value.X509CRL,
648		message_handle,
649		options);
650	0	if(result != GLOBUS_SUCCESS)
651		{
652	0	result = GlobusSoapMessageErrorSerializeFailed(
653		result, NULL, &ds_X509DataType_choice_qname);
654	0	goto exit;
655		}
656
657	0	break;
658
659		case ds_X509DataType_any:
660
661	0	subelement.local = "any";
662	0	subelement.Namespace = "http://www.w3.org/2001/XMLSchema";
663	0	result = xsd_any_serialize(
664		&subelement,
665		&instance->value.any,
666		message_handle,
667		options);
668	0	if(result != GLOBUS_SUCCESS)
669		{
670	0	result = GlobusSoapMessageErrorSerializeFailed(
671		result, NULL, &ds_X509DataType_choice_qname);
672		goto exit;
673		}
674
675	0	break;
676
677		default:
678	0	break;
679		}
680
681		exit:
682
683	0	GlobusSoapMessageDebugExit();
684	0	return result;
685		}
686
687
688
689		globus_result_t
690		ds_X509DataType_choice_serialize(
691		const xsd_QName *                   element_qname,
692		const ds_X509DataType_choice *       instance,
693		globus_soap_message_handle_t        message_handle,
694		globus_xsd_element_options_t        options)
695	0	{
696	0	globus_result_t                     result = GLOBUS_SUCCESS;
697	0	GlobusFuncName(ds_X509DataType_choice_serialize);
698	0	GlobusSoapMessageDebugEnter();
699
700	0	result = ds_X509DataType_choice_serialize_contents(
701		element_qname,
702		instance,
703		message_handle,
704		options);
705	0	if(result != GLOBUS_SUCCESS)
706		{
707	0	result = GlobusSoapMessageErrorSerializeFailed(
708		result, NULL, &ds_X509DataType_choice_qname);
709		goto exit;
710		}
711
712		exit:
713	0	GlobusSoapMessageDebugExit();
714	0	return result;
715		}
716
717
718
719
720
721		globus_result_t
722		ds_X509DataType_choice_deserialize_contents(
723		const xsd_QName *                   element_qname, /* ignored */
724		ds_X509DataType_choice *             instance,
725		globus_soap_message_handle_t        message_handle,
726		globus_xsd_element_options_t        options)
727	0	{
728	0	globus_result_t                     result = GLOBUS_SUCCESS;
729	0	GlobusFuncName(ds_X509DataType_choice_deserialize_contents);
730	0	GlobusSoapMessageDebugEnter();
731
732	0	result = ds_X509DataType_choice_deserialize(
733		NULL,
734		instance,
735		message_handle,
736		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
737	0	if(result != GLOBUS_SUCCESS)
738		{
739	0	result = GlobusSoapMessageErrorDeserializeFailed(
740		result, element_qname);
741		goto exit;
742		}
743
744		exit:
745
746	0	GlobusSoapMessageDebugExit();
747	0	return result;
748		}
749
750
751
752		globus_result_t
753		ds_X509DataType_choice_deserialize(
754		const xsd_QName *                   element_qname,
755		ds_X509DataType_choice *             instance,
756		globus_soap_message_handle_t        message_handle,
757		globus_xsd_element_options_t        options)
758	0	{
759	0	globus_result_t                     result = GLOBUS_SUCCESS;
760	0	xsd_QName                           subelement;
761	0	xsd_QName                           deselem_qname = { NULL, NULL } ;
762	0	GlobusFuncName(ds_X509DataType_choice_deserialize);
763	0	GlobusSoapMessageDebugEnter();
764
765	0	xsd_QName_init_contents(&deselem_qname);
766
767	0	do
768		{
769	0	result = globus_soap_message_deserialize_element_unknown(
770		message_handle, &deselem_qname);
771	0	if(result != GLOBUS_SUCCESS)
772		{
773	0	result = GlobusSoapMessageErrorDeserializeFailed(
774		result, &ds_X509DataType_choice_qname);
775	0	goto exit;
776		}
777
778	0	if(globus_soap_message_deserialize_element_is_nil(message_handle))
779		{
780	0	xsd_QName_destroy_contents(&deselem_qname);
781	0	result = globus_soap_message_deserialize_element_end(
782		message_handle,
783		element_qname);
784	0	if(result != GLOBUS_SUCCESS)
785		{
786	0	result = GlobusSoapMessageErrorDeserializeFailed(
787		result, &ds_X509DataType_choice_qname);
788	0	goto exit;
789		}
790		}
791		else
792		{
793	0	break;
794		}
795	0	} while(1);
796
797	0	globus_soap_message_deserialize_push_element(message_handle);
798
799	0	subelement.local = "X509IssuerSerial";
800	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
801	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
802		{
803	0	instance->type=ds_X509DataType_X509IssuerSerial;
804	0	result = ds_X509IssuerSerialType_deserialize(
805		&subelement,
806		&instance->value.X509IssuerSerial,
807		message_handle,
808		options);
809	0	if(result != GLOBUS_SUCCESS)
810		{
811	0	result = GlobusSoapMessageErrorDeserializeFailed(
812		result, &ds_X509DataType_choice_qname);
813	0	goto X509IssuerSerial_destroy;
814		}
815
816	0	goto exit;
817		}
818
819	0	subelement.local = "X509SKI";
820	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
821	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
822		{
823	0	instance->type=ds_X509DataType_X509SKI;
824	0	result = xsd_base64Binary_deserialize(
825		&subelement,
826		&instance->value.X509SKI,
827		message_handle,
828		options);
829	0	if(result != GLOBUS_SUCCESS)
830		{
831	0	result = GlobusSoapMessageErrorDeserializeFailed(
832		result, &ds_X509DataType_choice_qname);
833	0	goto X509SKI_destroy;
834		}
835
836	0	goto exit;
837		}
838
839	0	subelement.local = "X509SubjectName";
840	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
841	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
842		{
843	0	instance->type=ds_X509DataType_X509SubjectName;
844	0	result = xsd_string_deserialize(
845		&subelement,
846		&instance->value.X509SubjectName,
847		message_handle,
848		options);
849	0	if(result != GLOBUS_SUCCESS)
850		{
851	0	result = GlobusSoapMessageErrorDeserializeFailed(
852		result, &ds_X509DataType_choice_qname);
853	0	goto X509SubjectName_destroy;
854		}
855
856	0	goto exit;
857		}
858
859	0	subelement.local = "X509Certificate";
860	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
861	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
862		{
863	0	instance->type=ds_X509DataType_X509Certificate;
864	0	result = xsd_base64Binary_deserialize(
865		&subelement,
866		&instance->value.X509Certificate,
867		message_handle,
868		options);
869	0	if(result != GLOBUS_SUCCESS)
870		{
871	0	result = GlobusSoapMessageErrorDeserializeFailed(
872		result, &ds_X509DataType_choice_qname);
873	0	goto X509Certificate_destroy;
874		}
875
876	0	goto exit;
877		}
878
879	0	subelement.local = "X509CRL";
880	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
881	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
882		{
883	0	instance->type=ds_X509DataType_X509CRL;
884	0	result = xsd_base64Binary_deserialize(
885		&subelement,
886		&instance->value.X509CRL,
887		message_handle,
888		options);
889	0	if(result != GLOBUS_SUCCESS)
890		{
891	0	result = GlobusSoapMessageErrorDeserializeFailed(
892		result, &ds_X509DataType_choice_qname);
893	0	goto X509CRL_destroy;
894		}
895
896	0	goto exit;
897		}
898
899		/* try to parse as any element */
900	0	result = xsd_any_deserialize(
901		&subelement,
902		&instance->value.any,
903		message_handle,
904		options);
905	0	if(result != GLOBUS_SUCCESS)
906		{
907	0	result = GlobusSoapMessageErrorDeserializeFailed(
908		result, &ds_X509DataType_choice_qname);
909	0	goto any_destroy;
910		}
911		else
912		{
913	0	instance->type=ds_X509DataType_any;
914		goto exit;
915		}
916
917	0	instance->type = ds_X509DataType_undefined;
918	0	result = GlobusSoapMessageErrorDeserializeFailed(
919		result, &ds_X509DataType_choice_qname);
920
921	0	goto exit;
922
923		deserialize_failed:
924
925		any_destroy:
926
927		X509CRL_destroy:
928
929		X509Certificate_destroy:
930
931		X509SubjectName_destroy:
932
933		X509SKI_destroy:
934
935		X509IssuerSerial_destroy:
936
937		exit:
938
939	0	xsd_QName_destroy_contents(&deselem_qname);
940
941	0	if(result == GLOBUS_SUCCESS)
942		{
943	0	do
944		{
945	0	result = globus_soap_message_deserialize_element(
946		message_handle, NULL);
947	0	if(result != GLOBUS_SUCCESS &&
948		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
949		GlobusSoapMessageStatusFailedElementCheck(result) ||
950		GlobusSoapMessageStatusFailedWithTextCheck(result)))
951		{
952	0	result = GLOBUS_SUCCESS;
953	0	break;
954		}
955
956	0	if(globus_soap_message_deserialize_element_is_nil(
957		message_handle))
958		{
959	0	result = globus_soap_message_deserialize_element_end(
960		message_handle,
961		element_qname);
962	0	if(result != GLOBUS_SUCCESS)
963		{
964	0	result = GlobusSoapMessageErrorDeserializeFailed(
965		result, &ds_X509DataType_choice_qname);
966		break;
967		}
968		}
969		else
970		{
971	0	break;
972		}
973
974	0	} while(1);
975		}
976
977	0	xsd_QName_destroy_contents(&deselem_qname);
978
979	0	GlobusSoapMessageDebugExit();
980	0	return result;
981		}
982
983
984
985		globus_result_t
986		ds_X509DataType_choice_deserialize_pointer(
987		const xsd_QName *                   element_qname,
988		ds_X509DataType_choice **            ip,
989		globus_soap_message_handle_t        message_handle,
990		globus_xsd_element_options_t        options)
991	0	{
992	0	ds_X509DataType_choice * instance = NULL;
993	0	globus_result_t                     result = GLOBUS_SUCCESS;
994	0	xsd_QName                           subelement;
995	0	GlobusFuncName(ds_X509DataType_choice_deserialize_pointer);
996	0	GlobusSoapMessageDebugEnter();
997
998	0	*ip = NULL;
999
1000	0	result = ds_X509DataType_choice_init(&instance);
1001	0	if(result != GLOBUS_SUCCESS)
1002		{
1003	0	result = GlobusSoapMessageErrorDeserializeFailed(
1004		result, element_qname);
1005	0	goto exit;
1006		}
1007
1008	0	result = ds_X509DataType_choice_deserialize(
1009		element_qname,
1010		instance,
1011		message_handle,
1012		options);
1013	0	if(result != GLOBUS_SUCCESS)
1014		{
1015	0	goto exit;
1016		}
1017
1018	0	*ip = instance;
1019
1020		exit:
1021
1022	0	GlobusSoapMessageDebugExit();
1023	0	return result;
1024		}
1025
1026
1027
1028		globus_result_t
1029		ds_X509DataType_choice_array_init_contents(
1030		ds_X509DataType_choice_array * array)
1031	0	{
1032	0	return globus_xsd_generic_array_init_contents(
1033		(globus_xsd_generic_array_t *) array,
1034		&ds_X509DataType_choice_array_info);
1035		}
1036		/* ds_X509DataType_choice_array_init_contents() */
1037
1038		globus_result_t
1039		ds_X509DataType_choice_array_init(
1040		ds_X509DataType_choice_array ** arr)
1041	0	{
1042	0	return globus_xsd_generic_array_init(
1043		(globus_xsd_generic_array_t **) arr,
1044		&ds_X509DataType_choice_info);
1045		}
1046		/* ds_X509DataType_choice_array_init() */
1047
1048		void
1049		ds_X509DataType_choice_array_destroy_contents(
1050		ds_X509DataType_choice_array * array)
1051	0	{
1052	0	globus_xsd_generic_array_destroy_contents(
1053		(globus_xsd_generic_array_t *) array);
1054		}
1055		/* ds_X509DataType_choice_array_destroy_contents() */
1056
1057		void
1058		ds_X509DataType_choice_array_destroy(
1059		ds_X509DataType_choice_array * array)
1060	0	{
1061	0	globus_xsd_generic_array_destroy(
1062		(globus_xsd_generic_array_t *) array);
1063		}
1064		/* ds_X509DataType_choice_array_destroy() */
1065
1066		globus_result_t
1067		ds_X509DataType_choice_array_copy(
1068		ds_X509DataType_choice_array ** dest_arr,
1069		const ds_X509DataType_choice_array * src_arr)
1070	0	{
1071	0	return globus_xsd_generic_array_copy(
1072		(globus_xsd_generic_array_t **) dest_arr,
1073		(const globus_xsd_generic_array_t *) src_arr);
1074		}
1075		/* ds_X509DataType_choice_array_copy() */
1076
1077		globus_result_t
1078		ds_X509DataType_choice_array_copy_contents(
1079		ds_X509DataType_choice_array * dest_arr,
1080		const ds_X509DataType_choice_array * src_arr)
1081	0	{
1082	0	return globus_xsd_generic_array_copy_contents(
1083		(globus_xsd_generic_array_t *) dest_arr,
1084		(const globus_xsd_generic_array_t *) src_arr);
1085		}
1086
1087		ds_X509DataType_choice *
1088		ds_X509DataType_choice_array_push(
1089		ds_X509DataType_choice_array * array)
1090	0	{
1091		/* Some contents initializers don't initialize subelments but to set their
1092		* values to be NULL
1093		*/
1094	0	if (array->type_info == NULL)
1095		{
1096	0	array->type_info = &ds_X509DataType_choice_info;
1097		}
1098	0	return globus_xsd_generic_array_push(
1099		(globus_xsd_generic_array_t *) array);
1100		}
1101		/* ds_X509DataType_choice_array_push() */
1102
1103		void *
1104		ds_X509DataType_choice_array_push_wrapper(
1105		void * array)
1106	0	{
1107	0	return (void *) ds_X509DataType_choice_array_push(
1108		(ds_X509DataType_choice_array *) array);
1109		}
1110
1111		globus_result_t
1112		ds_X509DataType_choice_array_serialize(
1113		const xsd_QName *                   element_qname,
1114		const ds_X509DataType_choice_array * array,
1115		globus_soap_message_handle_t        message,
1116		globus_xsd_element_options_t        options)
1117	0	{
1118	0	return globus_xsd_generic_array_serialize(
1119		element_qname,
1120		(const globus_xsd_generic_array_t *) array,
1121		message,
1122		options);
1123		}
1124		/* ds_X509DataType_choice_array_serialize() */
1125
1126		globus_result_t
1127		ds_X509DataType_choice_array_deserialize(
1128		const xsd_QName *                   element_qname,
1129		ds_X509DataType_choice_array *       array,
1130		globus_soap_message_handle_t        message,
1131		globus_xsd_element_options_t        options)
1132	0	{
1133		/* Some initializers set the array's contents to NULL */
1134	0	if (array->type_info == NULL)
1135		{
1136	0	array->type_info = &ds_X509DataType_choice_info;
1137		}
1138	0	return globus_xsd_generic_array_deserialize(
1139		element_qname,
1140		(globus_xsd_generic_array_t *) array,
1141		message,
1142		options);
1143		}