1		/*
2		* Portions of this file Copyright 1999-2005 University of Chicago
3		* Portions of this file Copyright 1999-2005 The University of Southern California.
4		*
5		* This file or a portion of this file is licensed under the
6		* terms of the Globus Toolkit Public License, found at
7		* http://www.globus.org/toolkit/download/license.html.
8		* If you redistribute this file, with or without
9		* modifications, you must include this notice in the file.
10		*/
11
12
13		/*
14		* This file is automatically generated by the Globus WSDLtoC converter
15		*/
16
17		#include "xsd_QName.h"
18		#include "globus_soap_message.h"
19		#include "globus_xsd_type_info.h"
20		#include "ds_KeyInfoType.h"
21
22		xsd_QName ds_KeyInfoType_choice_qname =
23		{
24		"http://www.w3.org/2000/09/xmldsig#",
25		"KeyInfoType_choice"
26		};
27
28		globus_result_t
29		ds_KeyInfoType_choice_serialize_wrapper(
30		xsd_QName *                         element_qname,
31		void *                              instance,
32		globus_soap_message_handle_t        message_handle,
33		globus_xsd_element_options_t        options)
34	0	{
35	0	return ds_KeyInfoType_choice_serialize(
36		element_qname,
37		(ds_KeyInfoType_choice *) instance,
38		message_handle, options);
39		}
40
41		globus_result_t
42		ds_KeyInfoType_choice_deserialize_pointer_wrapper(
43		xsd_QName *                         element_qname,
44		void **                             ip,
45		globus_soap_message_handle_t        message_handle,
46		globus_xsd_element_options_t        options)
47	0	{
48	0	return ds_KeyInfoType_choice_deserialize_pointer(
49		element_qname,
50		(ds_KeyInfoType_choice **) ip,
51		message_handle, options);
52		}
53
54		globus_result_t
55		ds_KeyInfoType_choice_init_wrapper(void **object)
56	0	{
57	0	return ds_KeyInfoType_choice_init(
58		(ds_KeyInfoType_choice **) object);
59		}
60
61		void
62		ds_KeyInfoType_choice_destroy_wrapper(
63		void *                          object)
64	0	{
65	0	ds_KeyInfoType_choice_destroy(
66		(ds_KeyInfoType_choice *) object);
67		}
68
69		globus_result_t
70		ds_KeyInfoType_choice_copy_wrapper(
71		void **                         dest_obj,
72		void *                          src_obj)
73	0	{
74	0	return ds_KeyInfoType_choice_copy(
75		(ds_KeyInfoType_choice **) dest_obj,
76		(ds_KeyInfoType_choice *) src_obj);
77		}
78
79		globus_result_t
80		ds_KeyInfoType_choice_init_contents_wrapper(void *object)
81	0	{
82	0	return ds_KeyInfoType_choice_init_contents(
83		(ds_KeyInfoType_choice *) object);
84		}
85
86		void
87		ds_KeyInfoType_choice_destroy_contents_wrapper(
88		void *                          object)
89	0	{
90	0	ds_KeyInfoType_choice_destroy_contents(
91		(ds_KeyInfoType_choice *) object);
92		}
93
94		globus_result_t
95		ds_KeyInfoType_choice_copy_contents_wrapper(
96		void *                          dest_obj,
97		void *                          src_obj)
98	0	{
99	0	return ds_KeyInfoType_choice_copy_contents(
100		(ds_KeyInfoType_choice *) dest_obj,
101		(ds_KeyInfoType_choice *) src_obj);
102		}
103
104		globus_result_t
105		ds_KeyInfoType_choice_serialize_contents_wrapper(
106		xsd_QName *                         element_qname,
107		void *                              instance,
108		globus_soap_message_handle_t        message_handle,
109		globus_xsd_element_options_t        options)
110	0	{
111	0	return ds_KeyInfoType_choice_serialize_contents(
112		element_qname,
113		(ds_KeyInfoType_choice *) instance,
114		message_handle, options);
115		}
116
117		globus_result_t
118		ds_KeyInfoType_choice_deserialize_contents_wrapper(
119		xsd_QName *                         element_qname,
120		void **                             instance,
121		globus_soap_message_handle_t        message_handle,
122		globus_xsd_element_options_t        options)
123	0	{
124	0	globus_result_t                     result;
125	0	GlobusFuncName(ds_KeyInfoType_choice_deserialize_contents_wrapper);
126	0	GlobusSoapMessageDebugEnter();
127
128	0	if(!*instance)
129		{
130	0	result = ds_KeyInfoType_choice_init(
131		(ds_KeyInfoType_choice **)instance);
132	0	if(result != GLOBUS_SUCCESS)
133		{
134	0	goto error;
135		}
136		}
137
138	0	result = ds_KeyInfoType_choice_deserialize_contents(
139		element_qname,
140		*(ds_KeyInfoType_choice **)instance,
141		message_handle, options);
142		error:
143	0	GlobusSoapMessageDebugExit();
144	0	return result;
145		}
146
147		globus_result_t
148		ds_KeyInfoType_choice_array_serialize_wrapper(
149		xsd_QName *                     element,
150		void *                          instance,
151		globus_soap_message_handle_t    message,
152		globus_xsd_element_options_t    options)
153	0	{
154	0	return ds_KeyInfoType_choice_array_serialize(
155		element,
156		(ds_KeyInfoType_choice_array *) instance,
157		message, options);
158		}
159
160		globus_result_t
161		ds_KeyInfoType_choice_array_deserialize_wrapper(
162		xsd_QName *                         element_qname,
163		void **                             inst,
164		globus_soap_message_handle_t        message,
165		globus_xsd_element_options_t        options)
166	0	{
167	0	if(!*inst)
168		{
169	0	globus_result_t                 result;
170
171	0	result = ds_KeyInfoType_choice_array_init(
172		(ds_KeyInfoType_choice_array **)inst);
173	0	if(result != GLOBUS_SUCCESS)
174		{
175	0	return result;
176		}
177		}
178
179	0	return ds_KeyInfoType_choice_array_deserialize(
180		element_qname,
181		*(ds_KeyInfoType_choice_array **) inst,
182		message, options);
183		}
184
185		globus_result_t
186		ds_KeyInfoType_choice_array_init_wrapper(
187		void **                             arr)
188	0	{
189	0	return ds_KeyInfoType_choice_array_init(
190		(ds_KeyInfoType_choice_array **) arr);
191		}
192
193		void
194		ds_KeyInfoType_choice_array_destroy_wrapper(
195		void *                              arr)
196	0	{
197	0	ds_KeyInfoType_choice_array_destroy(
198		(ds_KeyInfoType_choice_array *) arr);
199		}
200
201		globus_result_t
202		ds_KeyInfoType_choice_array_copy_wrapper(
203		void **                             dest_arr,
204		void *                              src_arr)
205	0	{
206	0	return ds_KeyInfoType_choice_array_copy(
207		(ds_KeyInfoType_choice_array **) dest_arr,
208		(ds_KeyInfoType_choice_array *) src_arr);
209		}
210
211		globus_result_t
212		ds_KeyInfoType_choice_array_init_contents_wrapper(
213		void *                              arr)
214	0	{
215	0	return ds_KeyInfoType_choice_array_init_contents(
216		(ds_KeyInfoType_choice_array *) arr);
217		}
218
219		void
220		ds_KeyInfoType_choice_array_destroy_contents_wrapper(
221		void *                              arr)
222	0	{
223	0	ds_KeyInfoType_choice_array_destroy_contents(
224		(ds_KeyInfoType_choice_array *) arr);
225		}
226
227		globus_result_t
228		ds_KeyInfoType_choice_array_copy_contents_wrapper(
229		void *                              dest_arr,
230		void *                              src_arr)
231	0	{
232	0	return ds_KeyInfoType_choice_array_copy_contents(
233		(ds_KeyInfoType_choice_array *) dest_arr,
234		(ds_KeyInfoType_choice_array *) src_arr);
235		}
236
237		struct globus_xsd_type_info_s ds_KeyInfoType_choice_array_info =
238		{
239		&ds_KeyInfoType_choice_qname,
240		ds_KeyInfoType_choice_array_serialize_wrapper,
241		ds_KeyInfoType_choice_array_deserialize_wrapper,
242		ds_KeyInfoType_choice_array_init_wrapper,
243		ds_KeyInfoType_choice_array_destroy_wrapper,
244		ds_KeyInfoType_choice_array_copy_wrapper,
245		ds_KeyInfoType_choice_array_init_contents_wrapper,
246		ds_KeyInfoType_choice_array_destroy_contents_wrapper,
247		ds_KeyInfoType_choice_array_copy_contents_wrapper,
248		sizeof(ds_KeyInfoType_choice),
249		ds_KeyInfoType_choice_array_push_wrapper,
250		NULL,
251		NULL
252		};
253
254		struct globus_xsd_type_info_s ds_KeyInfoType_choice_contents_info =
255		{
256		&ds_KeyInfoType_choice_qname,
257		ds_KeyInfoType_choice_serialize_contents_wrapper,
258		ds_KeyInfoType_choice_deserialize_contents_wrapper,
259		ds_KeyInfoType_choice_init_wrapper,
260		ds_KeyInfoType_choice_destroy_wrapper,
261		ds_KeyInfoType_choice_copy_wrapper,
262		ds_KeyInfoType_choice_init_contents_wrapper,
263		ds_KeyInfoType_choice_destroy_contents_wrapper,
264		ds_KeyInfoType_choice_copy_contents_wrapper,
265		sizeof(ds_KeyInfoType_choice),
266		NULL,
267		NULL,
268		NULL
269		};
270
271		struct globus_xsd_type_info_s ds_KeyInfoType_choice_info =
272		{
273		&ds_KeyInfoType_choice_qname,
274		ds_KeyInfoType_choice_serialize_wrapper,
275		ds_KeyInfoType_choice_deserialize_pointer_wrapper,
276		ds_KeyInfoType_choice_init_wrapper,
277		ds_KeyInfoType_choice_destroy_wrapper,
278		ds_KeyInfoType_choice_copy_wrapper,
279		ds_KeyInfoType_choice_init_contents_wrapper,
280		ds_KeyInfoType_choice_destroy_contents_wrapper,
281		ds_KeyInfoType_choice_copy_contents_wrapper,
282		sizeof(ds_KeyInfoType),
283		NULL,
284		&ds_KeyInfoType_choice_contents_info,
285		&ds_KeyInfoType_choice_array_info
286		};
287
288		globus_result_t
289		ds_KeyInfoType_choice_init_contents(
290		ds_KeyInfoType_choice *                    instance)
291	0	{
292	0	globus_result_t                     result = GLOBUS_SUCCESS;
293	0	GlobusFuncName(ds_KeyInfoType_choice_init_contents);
294	0	GlobusSoapMessageDebugEnter();
295
296	0	memset(instance, 0, sizeof(ds_KeyInfoType));
297
298	0	GlobusSoapMessageDebugExit();
299	0	return result;
300		}
301
302		globus_result_t
303		ds_KeyInfoType_choice_init(
304		ds_KeyInfoType_choice ** object)
305	0	{
306	0	ds_KeyInfoType_choice * instance;
307	0	globus_result_t                     result = GLOBUS_SUCCESS;
308	0	GlobusFuncName(ds_KeyInfoType_choice_init);
309	0	GlobusSoapMessageDebugEnter();
310
311	0	instance = globus_malloc(sizeof(ds_KeyInfoType_choice));
312	0	if(!instance)
313		{
314	0	result = GlobusSoapMessageErrorOutOfMemory;
315	0	goto exit;
316		}
317
318	0	memset(instance, 0, sizeof(ds_KeyInfoType_choice));
319
320	0	*object = instance;
321
322		exit:
323	0	GlobusSoapMessageDebugExit();
324	0	return result;
325		}
326
327		void
328		ds_KeyInfoType_choice_destroy(
329		ds_KeyInfoType_choice * instance)
330	0	{
331	0	GlobusFuncName(ds_KeyInfoType_choice_destroy);
332	0	GlobusSoapMessageDebugEnter();
333
334	0	if(!instance)
335		{
336	0	goto exit;
337		}
338
339	0	ds_KeyInfoType_choice_destroy_contents(instance);
340	0	free(instance);
341
342		exit:
343
344	0	GlobusSoapMessageDebugExit();
345		}
346
347
348
349		void
350		ds_KeyInfoType_choice_destroy_contents(
351		ds_KeyInfoType_choice * instance)
352	0	{
353	0	GlobusFuncName(ds_KeyInfoType_choice_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	switch(instance->type)
357		{
358
359		case ds_KeyInfoType_KeyName:
360
361	0	xsd_string_destroy_contents(
362		&instance->value.KeyName);
363	0	break;
364
365		case ds_KeyInfoType_KeyValue:
366
367	0	ds_KeyValueType_destroy_contents(
368		&instance->value.KeyValue);
369	0	break;
370
371		case ds_KeyInfoType_RetrievalMethod:
372
373	0	ds_RetrievalMethodType_destroy_contents(
374		&instance->value.RetrievalMethod);
375	0	break;
376
377		case ds_KeyInfoType_X509Data:
378
379	0	ds_X509DataType_destroy_contents(
380		&instance->value.X509Data);
381	0	break;
382
383		case ds_KeyInfoType_PGPData:
384
385	0	ds_PGPDataType_destroy_contents(
386		&instance->value.PGPData);
387	0	break;
388
389		case ds_KeyInfoType_SPKIData:
390
391	0	ds_SPKIDataType_destroy_contents(
392		&instance->value.SPKIData);
393	0	break;
394
395		case ds_KeyInfoType_MgmtData:
396
397	0	xsd_string_destroy_contents(
398		&instance->value.MgmtData);
399	0	break;
400
401		case ds_KeyInfoType_any:
402
403	0	xsd_any_destroy_contents(
404		&instance->value.any);
405		break;
406
407		default:
408	0	break;
409		}
410
411	0	instance->type = ds_KeyInfoType_undefined;
412
413	0	GlobusSoapMessageDebugExit();
414		}
415
416		globus_result_t
417		ds_KeyInfoType_choice_copy(
418		ds_KeyInfoType_choice ** dest_obj,
419		const ds_KeyInfoType_choice * src_obj)
420	0	{
421	0	globus_result_t                     result = GLOBUS_SUCCESS;
422	0	ds_KeyInfoType_choice * instance;
423	0	GlobusFuncName(ds_KeyInfoType_choice_copy);
424
425	0	GlobusSoapMessageDebugEnter();
426
427	0	instance = malloc(sizeof(ds_KeyInfoType_choice));
428	0	if (instance == NULL)
429		{
430	0	GlobusSoapMessageDebugExit();
431	0	return GlobusSoapMessageErrorOutOfMemory;
432		}
433
434	0	result = ds_KeyInfoType_choice_copy_contents(instance, src_obj);
435	0	if(result != GLOBUS_SUCCESS)
436		{
437	0	globus_free(instance);
438	0	GlobusSoapMessageDebugExit();
439	0	return GlobusSoapMessageErrorOutOfMemory;
440		}
441
442	0	*dest_obj = instance;
443	0	GlobusSoapMessageDebugExit();
444	0	return result;
445		}
446
447
448
449		globus_result_t
450		ds_KeyInfoType_choice_copy_contents(
451		ds_KeyInfoType_choice * instance,
452		const ds_KeyInfoType_choice * src_obj)
453	0	{
454	0	xsd_QName                           subelement;
455	0	globus_result_t                     result = GLOBUS_SUCCESS;
456	0	GlobusFuncName(ds_KeyInfoType_choice_copy_contents);
457
458	0	GlobusSoapMessageDebugEnter();
459
460	0	switch(src_obj->type)
461		{
462
463		case ds_KeyInfoType_KeyName:
464	0	instance->type = ds_KeyInfoType_KeyName;
465	0	result = xsd_string_copy_contents(
466		&instance->value.KeyName,
467		&src_obj->value.KeyName);
468	0	if(result != GLOBUS_SUCCESS)
469		{
470	0	result = GlobusSoapMessageErrorSerializeFailed(
471		result, NULL, &ds_KeyInfoType_choice_qname);
472	0	goto exit;
473		}
474
475	0	break;
476
477		case ds_KeyInfoType_KeyValue:
478	0	instance->type = ds_KeyInfoType_KeyValue;
479	0	result = ds_KeyValueType_copy_contents(
480		&instance->value.KeyValue,
481		&src_obj->value.KeyValue);
482	0	if(result != GLOBUS_SUCCESS)
483		{
484	0	result = GlobusSoapMessageErrorSerializeFailed(
485		result, NULL, &ds_KeyInfoType_choice_qname);
486	0	goto exit;
487		}
488
489	0	break;
490
491		case ds_KeyInfoType_RetrievalMethod:
492	0	instance->type = ds_KeyInfoType_RetrievalMethod;
493	0	result = ds_RetrievalMethodType_copy_contents(
494		&instance->value.RetrievalMethod,
495		&src_obj->value.RetrievalMethod);
496	0	if(result != GLOBUS_SUCCESS)
497		{
498	0	result = GlobusSoapMessageErrorSerializeFailed(
499		result, NULL, &ds_KeyInfoType_choice_qname);
500	0	goto exit;
501		}
502
503	0	break;
504
505		case ds_KeyInfoType_X509Data:
506	0	instance->type = ds_KeyInfoType_X509Data;
507	0	result = ds_X509DataType_copy_contents(
508		&instance->value.X509Data,
509		&src_obj->value.X509Data);
510	0	if(result != GLOBUS_SUCCESS)
511		{
512	0	result = GlobusSoapMessageErrorSerializeFailed(
513		result, NULL, &ds_KeyInfoType_choice_qname);
514	0	goto exit;
515		}
516
517	0	break;
518
519		case ds_KeyInfoType_PGPData:
520	0	instance->type = ds_KeyInfoType_PGPData;
521	0	result = ds_PGPDataType_copy_contents(
522		&instance->value.PGPData,
523		&src_obj->value.PGPData);
524	0	if(result != GLOBUS_SUCCESS)
525		{
526	0	result = GlobusSoapMessageErrorSerializeFailed(
527		result, NULL, &ds_KeyInfoType_choice_qname);
528	0	goto exit;
529		}
530
531	0	break;
532
533		case ds_KeyInfoType_SPKIData:
534	0	instance->type = ds_KeyInfoType_SPKIData;
535	0	result = ds_SPKIDataType_copy_contents(
536		&instance->value.SPKIData,
537		&src_obj->value.SPKIData);
538	0	if(result != GLOBUS_SUCCESS)
539		{
540	0	result = GlobusSoapMessageErrorSerializeFailed(
541		result, NULL, &ds_KeyInfoType_choice_qname);
542	0	goto exit;
543		}
544
545	0	break;
546
547		case ds_KeyInfoType_MgmtData:
548	0	instance->type = ds_KeyInfoType_MgmtData;
549	0	result = xsd_string_copy_contents(
550		&instance->value.MgmtData,
551		&src_obj->value.MgmtData);
552	0	if(result != GLOBUS_SUCCESS)
553		{
554	0	result = GlobusSoapMessageErrorSerializeFailed(
555		result, NULL, &ds_KeyInfoType_choice_qname);
556	0	goto exit;
557		}
558
559	0	break;
560
561		case ds_KeyInfoType_any:
562	0	instance->type = ds_KeyInfoType_any;
563	0	result = xsd_any_copy_contents(
564		&instance->value.any,
565		&src_obj->value.any);
566	0	if(result != GLOBUS_SUCCESS)
567		{
568	0	result = GlobusSoapMessageErrorSerializeFailed(
569		result, NULL, &ds_KeyInfoType_choice_qname);
570		goto exit;
571		}
572
573	0	break;
574
575		default:
576	0	break;
577		}
578
579		exit:
580
581	0	GlobusSoapMessageDebugExit();
582	0	return result;
583		}
584
585
586
587
588
589		globus_result_t
590		ds_KeyInfoType_choice_serialize_contents(
591		xsd_QName *                         element_qname, /* ignored */
592		ds_KeyInfoType_choice * instance,
593		globus_soap_message_handle_t        message_handle,
594		globus_xsd_element_options_t        options)
595	0	{
596	0	xsd_QName                           subelement;
597	0	globus_result_t                     result = GLOBUS_SUCCESS;
598	0	GlobusFuncName(ds_KeyInfoType_choice_serialize_contents);
599	0	GlobusSoapMessageDebugEnter();
600
601	0	switch(instance->type)
602		{
603
604		case ds_KeyInfoType_KeyName:
605
606	0	subelement.local = "KeyName";
607	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
608	0	result = xsd_string_serialize(
609		&subelement,
610		&instance->value.KeyName,
611		message_handle,
612		options);
613	0	if(result != GLOBUS_SUCCESS)
614		{
615	0	result = GlobusSoapMessageErrorSerializeFailed(
616		result, NULL, &ds_KeyInfoType_choice_qname);
617	0	goto exit;
618		}
619
620	0	break;
621
622		case ds_KeyInfoType_KeyValue:
623
624	0	subelement.local = "KeyValue";
625	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
626	0	result = ds_KeyValueType_serialize(
627		&subelement,
628		&instance->value.KeyValue,
629		message_handle,
630		options);
631	0	if(result != GLOBUS_SUCCESS)
632		{
633	0	result = GlobusSoapMessageErrorSerializeFailed(
634		result, NULL, &ds_KeyInfoType_choice_qname);
635	0	goto exit;
636		}
637
638	0	break;
639
640		case ds_KeyInfoType_RetrievalMethod:
641
642	0	subelement.local = "RetrievalMethod";
643	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
644	0	result = ds_RetrievalMethodType_serialize(
645		&subelement,
646		&instance->value.RetrievalMethod,
647		message_handle,
648		options);
649	0	if(result != GLOBUS_SUCCESS)
650		{
651	0	result = GlobusSoapMessageErrorSerializeFailed(
652		result, NULL, &ds_KeyInfoType_choice_qname);
653	0	goto exit;
654		}
655
656	0	break;
657
658		case ds_KeyInfoType_X509Data:
659
660	0	subelement.local = "X509Data";
661	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
662	0	result = ds_X509DataType_serialize(
663		&subelement,
664		&instance->value.X509Data,
665		message_handle,
666		options);
667	0	if(result != GLOBUS_SUCCESS)
668		{
669	0	result = GlobusSoapMessageErrorSerializeFailed(
670		result, NULL, &ds_KeyInfoType_choice_qname);
671	0	goto exit;
672		}
673
674	0	break;
675
676		case ds_KeyInfoType_PGPData:
677
678	0	subelement.local = "PGPData";
679	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
680	0	result = ds_PGPDataType_serialize(
681		&subelement,
682		&instance->value.PGPData,
683		message_handle,
684		options);
685	0	if(result != GLOBUS_SUCCESS)
686		{
687	0	result = GlobusSoapMessageErrorSerializeFailed(
688		result, NULL, &ds_KeyInfoType_choice_qname);
689	0	goto exit;
690		}
691
692	0	break;
693
694		case ds_KeyInfoType_SPKIData:
695
696	0	subelement.local = "SPKIData";
697	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
698	0	result = ds_SPKIDataType_serialize(
699		&subelement,
700		&instance->value.SPKIData,
701		message_handle,
702		options);
703	0	if(result != GLOBUS_SUCCESS)
704		{
705	0	result = GlobusSoapMessageErrorSerializeFailed(
706		result, NULL, &ds_KeyInfoType_choice_qname);
707	0	goto exit;
708		}
709
710	0	break;
711
712		case ds_KeyInfoType_MgmtData:
713
714	0	subelement.local = "MgmtData";
715	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
716	0	result = xsd_string_serialize(
717		&subelement,
718		&instance->value.MgmtData,
719		message_handle,
720		options);
721	0	if(result != GLOBUS_SUCCESS)
722		{
723	0	result = GlobusSoapMessageErrorSerializeFailed(
724		result, NULL, &ds_KeyInfoType_choice_qname);
725	0	goto exit;
726		}
727
728	0	break;
729
730		case ds_KeyInfoType_any:
731
732	0	subelement.local = "any";
733	0	subelement.Namespace = "http://www.w3.org/2001/XMLSchema";
734	0	result = xsd_any_serialize(
735		&subelement,
736		&instance->value.any,
737		message_handle,
738		options);
739	0	if(result != GLOBUS_SUCCESS)
740		{
741	0	result = GlobusSoapMessageErrorSerializeFailed(
742		result, NULL, &ds_KeyInfoType_choice_qname);
743		goto exit;
744		}
745
746	0	break;
747
748		default:
749	0	break;
750		}
751
752		exit:
753
754	0	GlobusSoapMessageDebugExit();
755	0	return result;
756		}
757
758
759
760		globus_result_t
761		ds_KeyInfoType_choice_serialize(
762		xsd_QName *                         element_qname,
763		ds_KeyInfoType_choice *             instance,
764		globus_soap_message_handle_t        message_handle,
765		globus_xsd_element_options_t        options)
766	0	{
767	0	globus_result_t                     result = GLOBUS_SUCCESS;
768	0	GlobusFuncName(ds_KeyInfoType_choice_serialize);
769	0	GlobusSoapMessageDebugEnter();
770
771	0	result = ds_KeyInfoType_choice_serialize_contents(
772		element_qname,
773		instance,
774		message_handle,
775		options);
776	0	if(result != GLOBUS_SUCCESS)
777		{
778	0	result = GlobusSoapMessageErrorSerializeFailed(
779		result, NULL, &ds_KeyInfoType_choice_qname);
780		goto exit;
781		}
782
783		exit:
784	0	GlobusSoapMessageDebugExit();
785	0	return result;
786		}
787
788
789
790
791
792		globus_result_t
793		ds_KeyInfoType_choice_deserialize_contents(
794		xsd_QName *                         element_qname, /* ignored */
795		ds_KeyInfoType_choice * instance,
796		globus_soap_message_handle_t        message_handle,
797		globus_xsd_element_options_t        options)
798	0	{
799	0	globus_result_t                     result = GLOBUS_SUCCESS;
800	0	GlobusFuncName(ds_KeyInfoType_choice_deserialize_contents);
801	0	GlobusSoapMessageDebugEnter();
802
803	0	result = ds_KeyInfoType_choice_deserialize(
804		NULL,
805		instance,
806		message_handle,
807		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
808	0	if(result != GLOBUS_SUCCESS)
809		{
810	0	result = GlobusSoapMessageErrorDeserializeFailed(
811		result, element_qname);
812		goto exit;
813		}
814
815		exit:
816
817	0	GlobusSoapMessageDebugExit();
818	0	return result;
819		}
820
821
822
823		globus_result_t
824		ds_KeyInfoType_choice_deserialize(
825		xsd_QName *                         element_qname,
826		ds_KeyInfoType_choice * instance,
827		globus_soap_message_handle_t        message_handle,
828		globus_xsd_element_options_t        options)
829	0	{
830	0	globus_result_t                     result = GLOBUS_SUCCESS;
831	0	xsd_QName                           subelement;
832	0	xsd_QName                           deselem_qname = { NULL, NULL } ;
833	0	GlobusFuncName(ds_KeyInfoType_choice_deserialize);
834	0	GlobusSoapMessageDebugEnter();
835
836	0	xsd_QName_init_contents(&deselem_qname);
837
838	0	do
839		{
840	0	result = globus_soap_message_deserialize_element_unknown(
841		message_handle, &deselem_qname);
842	0	if(result != GLOBUS_SUCCESS)
843		{
844	0	result = GlobusSoapMessageErrorDeserializeFailed(
845		result, &ds_KeyInfoType_choice_qname);
846	0	goto exit;
847		}
848
849	0	if(globus_soap_message_deserialize_element_is_nil(message_handle))
850		{
851	0	xsd_QName_destroy_contents(&deselem_qname);
852	0	result = globus_soap_message_deserialize_element_end(
853		message_handle,
854		element_qname);
855	0	if(result != GLOBUS_SUCCESS)
856		{
857	0	result = GlobusSoapMessageErrorDeserializeFailed(
858		result, &ds_KeyInfoType_choice_qname);
859	0	goto exit;
860		}
861		}
862		else
863		{
864	0	break;
865		}
866	0	} while(1);
867
868	0	globus_soap_message_deserialize_push_element(message_handle);
869
870	0	subelement.local = "KeyName";
871	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
872	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
873		{
874	0	instance->type=ds_KeyInfoType_KeyName;
875	0	result = xsd_string_deserialize(
876		&subelement,
877		&instance->value.KeyName,
878		message_handle,
879		options);
880	0	if(result != GLOBUS_SUCCESS)
881		{
882	0	result = GlobusSoapMessageErrorDeserializeFailed(
883		result, &ds_KeyInfoType_choice_qname);
884	0	goto KeyName_destroy;
885		}
886
887	0	goto exit;
888		}
889
890	0	subelement.local = "KeyValue";
891	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
892	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
893		{
894	0	instance->type=ds_KeyInfoType_KeyValue;
895	0	result = ds_KeyValueType_deserialize(
896		&subelement,
897		&instance->value.KeyValue,
898		message_handle,
899		options);
900	0	if(result != GLOBUS_SUCCESS)
901		{
902	0	result = GlobusSoapMessageErrorDeserializeFailed(
903		result, &ds_KeyInfoType_choice_qname);
904	0	goto KeyValue_destroy;
905		}
906
907	0	goto exit;
908		}
909
910	0	subelement.local = "RetrievalMethod";
911	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
912	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
913		{
914	0	instance->type=ds_KeyInfoType_RetrievalMethod;
915	0	result = ds_RetrievalMethodType_deserialize(
916		&subelement,
917		&instance->value.RetrievalMethod,
918		message_handle,
919		options);
920	0	if(result != GLOBUS_SUCCESS)
921		{
922	0	result = GlobusSoapMessageErrorDeserializeFailed(
923		result, &ds_KeyInfoType_choice_qname);
924	0	goto RetrievalMethod_destroy;
925		}
926
927	0	goto exit;
928		}
929
930	0	subelement.local = "X509Data";
931	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
932	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
933		{
934	0	instance->type=ds_KeyInfoType_X509Data;
935	0	result = ds_X509DataType_deserialize(
936		&subelement,
937		&instance->value.X509Data,
938		message_handle,
939		options);
940	0	if(result != GLOBUS_SUCCESS)
941		{
942	0	result = GlobusSoapMessageErrorDeserializeFailed(
943		result, &ds_KeyInfoType_choice_qname);
944	0	goto X509Data_destroy;
945		}
946
947	0	goto exit;
948		}
949
950	0	subelement.local = "PGPData";
951	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
952	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
953		{
954	0	instance->type=ds_KeyInfoType_PGPData;
955	0	result = ds_PGPDataType_deserialize(
956		&subelement,
957		&instance->value.PGPData,
958		message_handle,
959		options);
960	0	if(result != GLOBUS_SUCCESS)
961		{
962	0	result = GlobusSoapMessageErrorDeserializeFailed(
963		result, &ds_KeyInfoType_choice_qname);
964	0	goto PGPData_destroy;
965		}
966
967	0	goto exit;
968		}
969
970	0	subelement.local = "SPKIData";
971	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
972	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
973		{
974	0	instance->type=ds_KeyInfoType_SPKIData;
975	0	result = ds_SPKIDataType_deserialize(
976		&subelement,
977		&instance->value.SPKIData,
978		message_handle,
979		options);
980	0	if(result != GLOBUS_SUCCESS)
981		{
982	0	result = GlobusSoapMessageErrorDeserializeFailed(
983		result, &ds_KeyInfoType_choice_qname);
984	0	goto SPKIData_destroy;
985		}
986
987	0	goto exit;
988		}
989
990	0	subelement.local = "MgmtData";
991	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
992	0	if(xsd_QName_keyeq((void *)&subelement, (void *)&deselem_qname))
993		{
994	0	instance->type=ds_KeyInfoType_MgmtData;
995	0	result = xsd_string_deserialize(
996		&subelement,
997		&instance->value.MgmtData,
998		message_handle,
999		options);
1000	0	if(result != GLOBUS_SUCCESS)
1001		{
1002	0	result = GlobusSoapMessageErrorDeserializeFailed(
1003		result, &ds_KeyInfoType_choice_qname);
1004	0	goto MgmtData_destroy;
1005		}
1006
1007	0	goto exit;
1008		}
1009
1010		/* try to parse as any element */
1011	0	result = xsd_any_deserialize(
1012		&subelement,
1013		&instance->value.any,
1014		message_handle,
1015		options);
1016	0	if(result != GLOBUS_SUCCESS)
1017		{
1018	0	result = GlobusSoapMessageErrorDeserializeFailed(
1019		result, &ds_KeyInfoType_choice_qname);
1020	0	goto any_destroy;
1021		}
1022		else
1023		{
1024	0	instance->type=ds_KeyInfoType_any;
1025		goto exit;
1026		}
1027
1028	0	instance->type = ds_KeyInfoType_undefined;
1029
1030	0	goto exit;
1031
1032		deserialize_failed:
1033
1034		any_destroy:
1035
1036		MgmtData_destroy:
1037
1038		SPKIData_destroy:
1039
1040		PGPData_destroy:
1041
1042		X509Data_destroy:
1043
1044		RetrievalMethod_destroy:
1045
1046		KeyValue_destroy:
1047
1048		KeyName_destroy:
1049
1050		exit:
1051
1052	0	xsd_QName_destroy_contents(&deselem_qname);
1053
1054	0	if(result == GLOBUS_SUCCESS)
1055		{
1056	0	do
1057		{
1058	0	result = globus_soap_message_deserialize_element(
1059		message_handle, NULL);
1060	0	if(result != GLOBUS_SUCCESS &&
1061		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1062		GlobusSoapMessageStatusFailedElementCheck(result) ||
1063		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1064		{
1065	0	result = GLOBUS_SUCCESS;
1066	0	break;
1067		}
1068
1069	0	if(globus_soap_message_deserialize_element_is_nil(
1070		message_handle))
1071		{
1072	0	result = globus_soap_message_deserialize_element_end(
1073		message_handle,
1074		element_qname);
1075	0	if(result != GLOBUS_SUCCESS)
1076		{
1077	0	result = GlobusSoapMessageErrorDeserializeFailed(
1078		result, &ds_KeyInfoType_choice_qname);
1079		break;
1080		}
1081		}
1082		else
1083		{
1084	0	break;
1085		}
1086
1087	0	} while(1);
1088		}
1089
1090	0	xsd_QName_destroy_contents(&deselem_qname);
1091
1092	0	GlobusSoapMessageDebugExit();
1093	0	return result;
1094		}
1095
1096
1097
1098		globus_result_t
1099		ds_KeyInfoType_choice_deserialize_pointer(
1100		xsd_QName *                         element_qname,
1101		ds_KeyInfoType_choice ** ip,
1102		globus_soap_message_handle_t        message_handle,
1103		globus_xsd_element_options_t        options)
1104	0	{
1105	0	ds_KeyInfoType_choice * instance = NULL;
1106	0	globus_result_t                     result = GLOBUS_SUCCESS;
1107	0	xsd_QName                           subelement;
1108	0	GlobusFuncName(ds_KeyInfoType_choice_deserialize_pointer);
1109	0	GlobusSoapMessageDebugEnter();
1110
1111	0	*ip = NULL;
1112
1113	0	result = ds_KeyInfoType_choice_init(&instance);
1114	0	if(result != GLOBUS_SUCCESS)
1115		{
1116	0	result = GlobusSoapMessageErrorDeserializeFailed(
1117		result, element_qname);
1118	0	goto exit;
1119		}
1120
1121	0	result = ds_KeyInfoType_choice_deserialize_contents(
1122		element_qname,
1123		instance,
1124		message_handle,
1125		options);
1126	0	if(result != GLOBUS_SUCCESS)
1127		{
1128	0	goto exit;
1129		}
1130
1131	0	*ip = instance;
1132
1133		exit:
1134
1135	0	GlobusSoapMessageDebugExit();
1136	0	return result;
1137		}
1138
1139
1140
1141		globus_result_t
1142		ds_KeyInfoType_choice_array_init_contents(
1143		ds_KeyInfoType_choice_array * array)
1144	0	{
1145	0	GlobusFuncName(ds_KeyInfoType_choice_array_init_contents);
1146	0	GlobusSoapMessageDebugEnter();
1147
1148	0	memset(array, 0, sizeof(ds_KeyInfoType_choice_array));
1149
1150	0	GlobusSoapMessageDebugExit();
1151	0	return GLOBUS_SUCCESS;
1152		}
1153
1154		globus_result_t
1155		ds_KeyInfoType_choice_array_init(
1156		ds_KeyInfoType_choice_array ** arr)
1157	0	{
1158	0	ds_KeyInfoType_choice_array * array;
1159	0	globus_result_t                     result;
1160	0	GlobusFuncName(ds_KeyInfoType_choice_array_init);
1161	0	GlobusSoapMessageDebugEnter();
1162
1163	0	array = (ds_KeyInfoType_choice_array *)
1164		globus_malloc(sizeof(ds_KeyInfoType_choice_array));
1165	0	if(!array)
1166		{
1167	0	result = GlobusSoapMessageErrorOutOfMemory;
1168	0	goto exit;
1169		}
1170
1171	0	result = ds_KeyInfoType_choice_array_init_contents(array);
1172	0	if(result != GLOBUS_SUCCESS)
1173		{
1174	0	globus_free(array);
1175	0	array = NULL;
1176		}
1177
1178	0	*arr = array;
1179
1180		exit:
1181	0	GlobusSoapMessageDebugExit();
1182	0	return result;
1183		}
1184
1185		void
1186		ds_KeyInfoType_choice_array_destroy_contents(
1187		ds_KeyInfoType_choice_array * array)
1188	0	{
1189	0	int                                 i = 0;
1190	0	GlobusFuncName(ds_KeyInfoType_choice_array_destroy_contents);
1191	0	GlobusSoapMessageDebugEnter();
1192
1193	0	for(; i < array->length; ++i)
1194		{
1195	0	ds_KeyInfoType_choice_destroy_contents(&array->elements[i]);
1196		}
1197
1198	0	if(array->elements)
1199		{
1200	0	globus_free(array->elements);
1201	0	array->elements = NULL;
1202		}
1203	0	array->length = 0;
1204
1205	0	GlobusSoapMessageDebugExit();
1206		}
1207
1208		void
1209		ds_KeyInfoType_choice_array_destroy(
1210		ds_KeyInfoType_choice_array * array)
1211	0	{
1212	0	GlobusFuncName(ds_KeyInfoType_choice_array_destroy);
1213	0	GlobusSoapMessageDebugEnter();
1214
1215	0	ds_KeyInfoType_choice_array_destroy_contents(array);
1216	0	globus_free(array);
1217
1218	0	GlobusSoapMessageDebugExit();
1219		}
1220
1221		globus_result_t
1222		ds_KeyInfoType_choice_array_copy(
1223		ds_KeyInfoType_choice_array ** dest_arr,
1224		const ds_KeyInfoType_choice_array * src_arr)
1225	0	{
1226	0	ds_KeyInfoType_choice_array * array;
1227	0	globus_result_t                     result;
1228	0	GlobusFuncName(ds_KeyInfoType_choice_array_copy);
1229	0	GlobusSoapMessageDebugEnter();
1230
1231	0	array = (ds_KeyInfoType_choice_array *) malloc(
1232		sizeof(ds_KeyInfoType_choice_array));
1233	0	if(!array)
1234		{
1235	0	result = GlobusSoapMessageErrorOutOfMemory;
1236	0	GlobusSoapMessageDebugExit();
1237	0	return result;
1238		}
1239
1240	0	result = ds_KeyInfoType_choice_array_copy_contents(array, src_arr);
1241	0	if(result != GLOBUS_SUCCESS)
1242		{
1243	0	globus_free(array);
1244	0	GlobusSoapMessageDebugExit();
1245	0	return result;
1246		}
1247
1248	0	*dest_arr = array;
1249
1250	0	GlobusSoapMessageDebugExit();
1251	0	return GLOBUS_SUCCESS;
1252		}
1253
1254		globus_result_t
1255		ds_KeyInfoType_choice_array_copy_contents(
1256		ds_KeyInfoType_choice_array * dest_arr,
1257		const ds_KeyInfoType_choice_array * src_arr)
1258	0	{
1259	0	int                                 i;
1260	0	globus_result_t                     result = GLOBUS_SUCCESS;
1261	0	GlobusFuncName(ds_KeyInfoType_choice_array_copy_contents);
1262	0	GlobusSoapMessageDebugEnter();
1263
1264	0	dest_arr->length = src_arr->length;
1265	0	if(dest_arr->length > 0)
1266		{
1267	0	dest_arr->elements = (ds_KeyInfoType_choice *) malloc(
1268		sizeof(ds_KeyInfoType_choice) * dest_arr->length);
1269	0	if(!dest_arr->elements)
1270		{
1271	0	result = GlobusSoapMessageErrorOutOfMemory;
1272	0	goto exit;
1273		}
1274		}
1275		else
1276		{
1277	0	dest_arr->elements = NULL;
1278		}
1279
1280	0	for(i = 0; i < dest_arr->length; i++)
1281		{
1282	0	result = ds_KeyInfoType_choice_copy_contents(
1283		&dest_arr->elements[i], &src_arr->elements[i]);
1284	0	if(result != GLOBUS_SUCCESS)
1285		{
1286	0	while(i--)
1287		{
1288	0	ds_KeyInfoType_choice_destroy_contents(&dest_arr->elements[i]);
1289		}
1290
1291	0	globus_free(dest_arr->elements);
1292	0	dest_arr->elements = NULL;
1293	0	dest_arr->length = 0;
1294	0	break;
1295		}
1296		}
1297
1298		exit:
1299	0	GlobusSoapMessageDebugExit();
1300	0	return result;
1301		}
1302
1303		ds_KeyInfoType_choice *
1304		ds_KeyInfoType_choice_array_push(
1305		ds_KeyInfoType_choice_array * array)
1306	0	{
1307	0	ds_KeyInfoType_choice *             tmp;
1308
1309	0	GlobusFuncName(ds_KeyInfoType_choice_array_push);
1310	0	GlobusSoapMessageDebugEnter();
1311
1312	0	tmp = realloc(array->elements,
1313		sizeof(ds_KeyInfoType_choice) *
1314		(array->length + 1));
1315	0	if (tmp == NULL)
1316		{
1317	0	goto error;
1318		}
1319	0	array->elements = tmp;
1320
1321	0	memset(&array->elements[array->length], 0, sizeof(ds_KeyInfoType_choice));
1322	0	array->length++;
1323
1324	0	GlobusSoapMessageDebugExit();
1325	0	return (&array->elements[array->length - 1]);
1326		error:
1327	0	GlobusSoapMessageDebugExit();
1328	0	return NULL;
1329		}
1330
1331		void *
1332		ds_KeyInfoType_choice_array_push_wrapper(
1333		void * array)
1334	0	{
1335	0	return (void *) ds_KeyInfoType_choice_array_push(
1336		(ds_KeyInfoType_choice_array *) array);
1337		}
1338
1339		globus_result_t
1340		ds_KeyInfoType_choice_array_serialize(
1341		xsd_QName *                         element_qname,
1342		ds_KeyInfoType_choice_array * array,
1343		globus_soap_message_handle_t        message,
1344		globus_xsd_element_options_t        options)
1345	0	{
1346	0	globus_result_t                     result = GLOBUS_SUCCESS;
1347	0	int                                 i = 0;
1348	0	GlobusFuncName(ds_KeyInfoType_choice_array_serialize);
1349	0	GlobusSoapMessageDebugEnter();
1350
1351	0	for(; i < array->length; ++i)
1352		{
1353	0	result = ds_KeyInfoType_choice_serialize(
1354		element_qname,
1355		&array->elements[i],
1356		message,
1357		options);
1358	0	if(result != GLOBUS_SUCCESS)
1359		{
1360	0	goto exit;
1361		}
1362		}
1363
1364		exit:
1365
1366	0	GlobusSoapMessageDebugExit();
1367	0	return result;
1368		}
1369
1370		globus_result_t
1371		ds_KeyInfoType_choice_array_deserialize(
1372		xsd_QName *                         element_qname,
1373		ds_KeyInfoType_choice_array * array,
1374		globus_soap_message_handle_t        message,
1375		globus_xsd_element_options_t        options)
1376	0	{
1377	0	globus_result_t                     result = GLOBUS_SUCCESS;
1378	0	int                                 i = 0;
1379	0	int                                 pre_length;
1380	0	GlobusFuncName(ds_KeyInfoType_choice_array_deserialize);
1381	0	GlobusSoapMessageDebugEnter();
1382
1383	0	pre_length = array->length;
1384
1385	0	for(i = 0; i < pre_length; ++i)
1386		{
1387	0	result = ds_KeyInfoType_choice_deserialize(
1388		element_qname,
1389		&array->elements[i],
1390		message,
1391		options);
1392	0	if(result != GLOBUS_SUCCESS)
1393		{
1394	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1395		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1396		GlobusSoapMessageStatusFailedWithTextCheck(result))
1397		{
1398	0	result = GLOBUS_SUCCESS;
1399	0	break;
1400		}
1401
1402	0	result = GlobusSoapMessageErrorDeserializeFailed(
1403		result, element_qname);
1404	0	goto exit;
1405		}
1406		}
1407
1408	0	while(result == GLOBUS_SUCCESS)
1409		{
1410	0	ds_KeyInfoType_choice next;
1411	0	memset(&next, 0, sizeof(ds_KeyInfoType_choice));
1412
1413	0	result = ds_KeyInfoType_choice_deserialize(
1414		element_qname,
1415		&next,
1416		message,
1417		options);
1418	0	if(result != GLOBUS_SUCCESS)
1419		{
1420	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1421		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1422		GlobusSoapMessageStatusFailedWithTextCheck(result))
1423		{
1424	0	result = GLOBUS_SUCCESS;
1425	0	break;
1426		}
1427
1428	0	result = GlobusSoapMessageErrorDeserializeFailed(
1429		result, element_qname);
1430	0	goto exit;
1431		}
1432
1433	0	array->elements = realloc(
1434		array->elements,
1435		(array->length + 1) * sizeof(ds_KeyInfoType_choice));
1436	0	if(!array->elements)
1437		{
1438	0	result = GlobusSoapMessageErrorOutOfMemory;
1439	0	goto exit;
1440		}
1441	0	array->elements[array->length] = next;
1442	0	array->length++;
1443	0	++i;
1444		}
1445
1446		exit:
1447
1448	0	if(result != GLOBUS_SUCCESS)
1449		{
1450	0	int                             di = 0;
1451	0	for(; di < i; ++di)
1452		{
1453	0	ds_KeyInfoType_choice_destroy_contents(
1454		&array->elements[di]);
1455	0	memset(&array->elements[di], 0, sizeof(ds_KeyInfoType_choice));
1456		}
1457		}
1458
1459	0	GlobusSoapMessageDebugExit();
1460	0	return result;