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_KeyInfoType.h"
26
27		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
28		xsd_QName ds_KeyInfoType_qname =
29		{
30		DS_KEYINFOTYPE_NS,
31		DS_KEYINFOTYPE_LOCAL
32		};
33		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
34
35		globus_result_t
36		ds_KeyInfoType_serialize_wrapper(
37		const xsd_QName *                   element_qname,
38		const void *                        instance,
39		globus_soap_message_handle_t        message_handle,
40		globus_xsd_element_options_t        options)
41	0	{
42	0	return ds_KeyInfoType_serialize(
43		element_qname,
44		(const ds_KeyInfoType *) instance,
45		message_handle, options);
46		}
47
48		globus_result_t
49		ds_KeyInfoType_deserialize_pointer_wrapper(
50		const xsd_QName *                   element_qname,
51		void **                             ip,
52		globus_soap_message_handle_t        message_handle,
53		globus_xsd_element_options_t        options)
54	0	{
55	0	return ds_KeyInfoType_deserialize_pointer(
56		element_qname,
57		(ds_KeyInfoType **) ip,
58		message_handle, options);
59		}
60
61		globus_result_t
62		ds_KeyInfoType_init_wrapper(void **object)
63	0	{
64	0	return ds_KeyInfoType_init(
65		(ds_KeyInfoType **) object);
66		}
67
68		void
69		ds_KeyInfoType_destroy_wrapper(
70		void *                          object)
71	0	{
72	0	ds_KeyInfoType_destroy(
73		(ds_KeyInfoType *) object);
74		}
75
76		globus_result_t
77		ds_KeyInfoType_copy_wrapper(
78		void **                         dest_obj,
79		const void *                    src_obj)
80	0	{
81	0	return ds_KeyInfoType_copy(
82		(ds_KeyInfoType **) dest_obj,
83		(ds_KeyInfoType *) src_obj);
84		}
85
86		globus_result_t
87		ds_KeyInfoType_init_contents_wrapper(void *object)
88	0	{
89	0	return ds_KeyInfoType_init_contents(
90		(ds_KeyInfoType *) object);
91		}
92
93		void
94		ds_KeyInfoType_destroy_contents_wrapper(
95		void *                          object)
96	0	{
97	0	ds_KeyInfoType_destroy_contents(
98		(ds_KeyInfoType *) object);
99		}
100
101		globus_result_t
102		ds_KeyInfoType_copy_contents_wrapper(
103		void *                          dest_obj,
104		const void *                    src_obj)
105	0	{
106	0	return ds_KeyInfoType_copy_contents(
107		(ds_KeyInfoType *) dest_obj,
108		(const ds_KeyInfoType *) src_obj);
109		}
110
111		globus_result_t
112		ds_KeyInfoType_serialize_contents_wrapper(
113		const xsd_QName *                   element_qname,
114		const void *                        instance,
115		globus_soap_message_handle_t        message_handle,
116		globus_xsd_element_options_t        options)
117	0	{
118	0	return ds_KeyInfoType_serialize_contents(
119		element_qname,
120		(ds_KeyInfoType *) instance,
121		message_handle, options);
122		}
123
124		globus_result_t
125		ds_KeyInfoType_deserialize_contents_wrapper(
126		const xsd_QName *                   element_qname,
127		void **                             instance,
128		globus_soap_message_handle_t        message_handle,
129		globus_xsd_element_options_t        options)
130	0	{
131	0	globus_result_t                     result;
132	0	GlobusFuncName(ds_KeyInfoType_deserialize_contents_wrapper);
133	0	GlobusSoapMessageDebugEnter();
134
135	0	if(!*instance)
136		{
137	0	result = ds_KeyInfoType_init(
138		(ds_KeyInfoType **)instance);
139	0	if(result != GLOBUS_SUCCESS)
140		{
141	0	goto error;
142		}
143		}
144
145	0	result = ds_KeyInfoType_deserialize_contents(
146		element_qname,
147		*(ds_KeyInfoType **)instance,
148		message_handle, options);
149		error:
150	0	GlobusSoapMessageDebugExit();
151	0	return result;
152		}
153
154		globus_result_t
155		ds_KeyInfoType_array_serialize_wrapper(
156		const xsd_QName *               element,
157		const void *                    instance,
158		globus_soap_message_handle_t    message,
159		globus_xsd_element_options_t    options)
160	0	{
161	0	return ds_KeyInfoType_array_serialize(
162		element,
163		(ds_KeyInfoType_array *) instance,
164		message, options);
165		}
166
167		globus_result_t
168		ds_KeyInfoType_array_deserialize_wrapper(
169		const xsd_QName *                   element_qname,
170		void **                             inst,
171		globus_soap_message_handle_t        message,
172		globus_xsd_element_options_t        options)
173	0	{
174	0	if(!*inst)
175		{
176	0	globus_result_t                 result;
177
178	0	result = ds_KeyInfoType_array_init(
179		(ds_KeyInfoType_array **)inst);
180	0	if(result != GLOBUS_SUCCESS)
181		{
182	0	return result;
183		}
184		}
185
186	0	return ds_KeyInfoType_array_deserialize(
187		element_qname,
188		*(ds_KeyInfoType_array **) inst,
189		message, options);
190		}
191
192		globus_result_t
193		ds_KeyInfoType_array_init_wrapper(
194		void **                             arr)
195	0	{
196	0	return ds_KeyInfoType_array_init(
197		(ds_KeyInfoType_array **) arr);
198		}
199
200		void
201		ds_KeyInfoType_array_destroy_wrapper(
202		void *                              arr)
203	0	{
204	0	ds_KeyInfoType_array_destroy(
205		(ds_KeyInfoType_array *) arr);
206		}
207
208		globus_result_t
209		ds_KeyInfoType_array_copy_wrapper(
210		void **                             dest_arr,
211		const void *                        src_arr)
212	0	{
213	0	return ds_KeyInfoType_array_copy(
214		(ds_KeyInfoType_array **) dest_arr,
215		(const ds_KeyInfoType_array *) src_arr);
216		}
217
218		globus_result_t
219		ds_KeyInfoType_array_init_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	return ds_KeyInfoType_array_init_contents(
223		(ds_KeyInfoType_array *) arr);
224		}
225
226		void
227		ds_KeyInfoType_array_destroy_contents_wrapper(
228		void *                              arr)
229	0	{
230	0	ds_KeyInfoType_array_destroy_contents(
231		(ds_KeyInfoType_array *) arr);
232		}
233
234		globus_result_t
235		ds_KeyInfoType_array_copy_contents_wrapper(
236		void *                              dest_arr,
237		const void *                        src_arr)
238	0	{
239	0	return ds_KeyInfoType_array_copy_contents(
240		(ds_KeyInfoType_array *) dest_arr,
241		(const ds_KeyInfoType_array *) src_arr);
242		}
243
244		struct globus_xsd_type_info_s ds_KeyInfoType_contents_info =
245		{
246		&ds_KeyInfoType_qname,
247		ds_KeyInfoType_serialize_contents_wrapper,
248		ds_KeyInfoType_deserialize_contents_wrapper,
249		ds_KeyInfoType_init_wrapper,
250		ds_KeyInfoType_destroy_wrapper,
251		ds_KeyInfoType_copy_wrapper,
252		ds_KeyInfoType_init_contents_wrapper,
253		ds_KeyInfoType_destroy_contents_wrapper,
254		ds_KeyInfoType_copy_contents_wrapper,
255		sizeof(ds_KeyInfoType),
256		NULL,
257		NULL,
258		NULL
259		};
260
261		struct globus_xsd_type_info_s ds_KeyInfoType_array_info =
262		{
263		&ds_KeyInfoType_qname,
264		ds_KeyInfoType_array_serialize_wrapper,
265		ds_KeyInfoType_array_deserialize_wrapper,
266		ds_KeyInfoType_array_init_wrapper,
267		ds_KeyInfoType_array_destroy_wrapper,
268		ds_KeyInfoType_array_copy_wrapper,
269		ds_KeyInfoType_array_init_contents_wrapper,
270		ds_KeyInfoType_array_destroy_contents_wrapper,
271		ds_KeyInfoType_array_copy_contents_wrapper,
272		sizeof(ds_KeyInfoType),
273		ds_KeyInfoType_array_push_wrapper,
274		NULL,
275		NULL
276		};
277
278		struct globus_xsd_type_info_s ds_KeyInfoType_info =
279		{
280		&ds_KeyInfoType_qname,
281		ds_KeyInfoType_serialize_wrapper,
282		ds_KeyInfoType_deserialize_pointer_wrapper,
283		ds_KeyInfoType_init_wrapper,
284		ds_KeyInfoType_destroy_wrapper,
285		ds_KeyInfoType_copy_wrapper,
286		ds_KeyInfoType_init_contents_wrapper,
287		ds_KeyInfoType_destroy_contents_wrapper,
288		ds_KeyInfoType_copy_contents_wrapper,
289		sizeof(ds_KeyInfoType),
290		NULL,
291		&ds_KeyInfoType_contents_info,
292		&ds_KeyInfoType_array_info
293		};
294
295		globus_result_t
296		ds_KeyInfoType_init_contents(
297		ds_KeyInfoType * instance)
298	0	{
299	0	globus_result_t                     result = GLOBUS_SUCCESS;
300	0	GlobusFuncName(ds_KeyInfoType_init_contents);
301	0	GlobusSoapMessageDebugEnter();
302
303	0	memset(instance, 0, sizeof(ds_KeyInfoType));
304
305	0	GlobusSoapMessageDebugExit();
306	0	return result;
307		}
308
309		globus_result_t
310		ds_KeyInfoType_init(
311		ds_KeyInfoType ** object)
312	0	{
313	0	ds_KeyInfoType * instance;
314	0	globus_result_t                     result = GLOBUS_SUCCESS;
315	0	GlobusFuncName(ds_KeyInfoType_init);
316	0	GlobusSoapMessageDebugEnter();
317
318	0	instance = globus_malloc(sizeof(ds_KeyInfoType));
319	0	if(!instance)
320		{
321	0	result = GlobusSoapMessageErrorOutOfMemory;
322	0	goto exit;
323		}
324
325	0	memset(instance, 0, sizeof(ds_KeyInfoType));
326
327	0	*object = instance;
328
329		exit:
330	0	GlobusSoapMessageDebugExit();
331	0	return result;
332		}
333
334		void
335		ds_KeyInfoType_destroy(
336		ds_KeyInfoType * instance)
337	0	{
338	0	GlobusFuncName(ds_KeyInfoType_destroy);
339	0	GlobusSoapMessageDebugEnter();
340
341	0	if(!instance)
342		{
343	0	goto exit;
344		}
345
346	0	ds_KeyInfoType_destroy_contents(instance);
347	0	globus_free(instance);
348
349		exit:
350
351	0	GlobusSoapMessageDebugExit();
352		}
353
354
355		void
356		ds_KeyInfoType_destroy_contents(
357		ds_KeyInfoType * instance)
358	0	{
359	0	GlobusFuncName(ds_KeyInfoType_destroy_contents);
360	0	GlobusSoapMessageDebugEnter();
361
362	0	if(instance)
363		{
364
365
366	0	ds_KeyInfoType_choice_array_destroy_contents(&instance->choice_value);
367
368	0	if(instance->_Id)
369		{
370	0	xsd_ID_destroy(
371		instance->_Id);
372	0	instance->_Id = NULL;
373		}
374
375		}
376
377	0	GlobusSoapMessageDebugExit();
378		}
379
380
381		globus_result_t
382		ds_KeyInfoType_copy(
383		ds_KeyInfoType ** dest_obj,
384		const ds_KeyInfoType * src_obj)
385	0	{
386	0	globus_result_t                     result = GLOBUS_SUCCESS;
387	0	ds_KeyInfoType * instance;
388	0	GlobusFuncName(ds_KeyInfoType_copy);
389
390	0	GlobusSoapMessageDebugEnter();
391
392	0	instance = calloc(1, sizeof(ds_KeyInfoType));
393	0	if (instance == NULL)
394		{
395	0	GlobusSoapMessageDebugExit();
396	0	return GlobusSoapMessageErrorOutOfMemory;
397		}
398
399	0	result = ds_KeyInfoType_copy_contents(instance, src_obj);
400	0	if(result != GLOBUS_SUCCESS)
401		{
402	0	globus_free(instance);
403	0	GlobusSoapMessageDebugExit();
404	0	return GlobusSoapMessageErrorOutOfMemory;
405		}
406
407	0	*dest_obj = instance;
408	0	GlobusSoapMessageDebugExit();
409	0	return result;
410		}
411
412		globus_result_t
413		ds_KeyInfoType_copy_contents(
414		ds_KeyInfoType * instance,
415		const ds_KeyInfoType * src_obj)
416	0	{
417	0	globus_result_t                     result = GLOBUS_SUCCESS;
418	0	GlobusFuncName(ds_KeyInfoType_copy_contents);
419
420	0	GlobusSoapMessageDebugEnter();
421
422	0	if(src_obj->_Id)
423		{
424	0	result = xsd_ID_copy(
425		&instance->_Id,
426		src_obj->_Id);
427	0	if(result != GLOBUS_SUCCESS)
428		{
429	0	result = GlobusSoapMessageErrorCopyFailed(
430		result, NULL, &xsd_ID_qname);
431	0	goto _Id_destroy;
432		}
433		}
434		else
435		{
436	0	instance->_Id = NULL;
437		}
438
439	0	result = ds_KeyInfoType_choice_array_copy_contents(
440		&instance->choice_value,
441		&src_obj->choice_value);
442	0	if(result != GLOBUS_SUCCESS)
443		{
444	0	result = GlobusSoapMessageErrorCopyFailed(
445		result, NULL, &ds_KeyInfoType_choice_qname);
446	0	goto choice_value_destroy_array;
447		}
448
449	0	goto exit;
450
451		fail_deserialize:
452
453		_Id_destroy:
454
455	0	if(instance->_Id)
456		{
457	0	xsd_ID_destroy(
458		instance->_Id);
459	0	instance->_Id = NULL;
460		}
461	0	ds_KeyInfoType_choice_array_destroy_contents(
462		&instance->choice_value);
463
464		choice_value_destroy_array:
465
466
467		exit:
468
469	0	GlobusSoapMessageDebugExit();
470	0	return result;
471		}
472
473
474
475		globus_result_t
476		ds_KeyInfoType_serialize_contents(
477		const xsd_QName *                   element_qname, /* ignored */
478		const ds_KeyInfoType *              inst,
479		globus_soap_message_handle_t        message_handle,
480		globus_xsd_element_options_t        options)
481	0	{
482	0	globus_result_t                     result = GLOBUS_SUCCESS;
483	0	GlobusFuncName(ds_KeyInfoType_serialize_contents);
484	0	GlobusSoapMessageDebugEnter();
485
486	0	result = ds_KeyInfoType_serialize(
487		NULL,
488		inst,
489		message_handle,
490		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
491	0	if(result != GLOBUS_SUCCESS)
492		{
493	0	result = GlobusSoapMessageErrorSerializeFailed(
494		result, NULL, element_qname);
495		goto exit;
496		}
497
498		exit:
499
500	0	GlobusSoapMessageDebugExit();
501	0	return result;
502		}
503
504
505
506		globus_result_t
507		ds_KeyInfoType_serialize(
508		const xsd_QName *                   element_qname,
509		const ds_KeyInfoType *              instance,
510		globus_soap_message_handle_t        message_handle,
511		globus_xsd_element_options_t        options)
512	0	{
513	0	globus_result_t                     result = GLOBUS_SUCCESS;
514	0	xsd_QName                           subelement;
515	0	globus_list_t *                     any_attr_keys = NULL;
516	0	globus_list_t *                     any_attr_keys_iterator = NULL;
517	0	xsd_QName *                         type_attr = NULL;
518
519	0	xsd_QName *                         nil_attr = NULL;
520	0	char *                              prefix = NULL;
521	0	int                                 prefix_created;
522	0	int                                 define_prefix = 0;
523	0	int                                 save_options = options;
524
525	0	GlobusFuncName(ds_KeyInfoType_serialize);
526	0	GlobusSoapMessageDebugEnter();
527
528
529	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
530		{
531		/* serialize ds_KeyInfoType element */
532	0	result = globus_soap_message_element_ns_set(
533		message_handle,
534		element_qname,
535		element_qname->Namespace,
536		&options);
537	0	if(result != GLOBUS_SUCCESS)
538		{
539	0	result = GlobusSoapMessageErrorSerializeFailed(
540		result, NULL, element_qname);
541	0	goto exit;
542		}
543
544	0	if(instance->_Id)
545		{
546
547	0	result = globus_soap_message_attribute_ns_set(
548		message_handle,
549		element_qname,
550		NULL,
551		&options);
552
553	0	if(result != GLOBUS_SUCCESS)
554		{
555	0	xsd_QName               error_qname;
556	0	error_qname.local = prefix;
557	0	error_qname.Namespace = "";
558	0	result = GlobusSoapMessageErrorSerializeFailed(result,
559		NULL,
560		&error_qname);
561	0	goto exit;
562		}
563
564
565		}
566
567	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
568		!globus_soap_message_serialize_is_c14n_subset(message_handle))
569		|| (instance == NULL || (options & GLOBUS_XSD_ELEMENT_NIL)))
570		{
571	0	result = globus_soap_message_attribute_ns_set(
572		message_handle,
573		element_qname,
574		"http://www.w3.org/2001/XMLSchema-instance",
575		&options);
576	0	if(result != GLOBUS_SUCCESS)
577		{
578	0	result = GlobusSoapMessageErrorSerializeFailed(
579		result, NULL, element_qname);
580	0	goto exit;
581		}
582		}
583
584	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
585		!globus_soap_message_serialize_is_c14n_subset(message_handle))
586		{
587
588	0	result = globus_soap_message_attribute_ns_set(
589		message_handle,
590		element_qname,
591		ds_KeyInfoType_qname.Namespace,
592		&options);
593	0	if(result != GLOBUS_SUCCESS)
594		{
595	0	result = GlobusSoapMessageErrorSerializeFailed(
596		result, NULL, element_qname);
597	0	goto exit;
598		}
599		}
600
601	0	result = globus_soap_message_serialize_element(
602		message_handle,
603		element_qname,
604		options,
605		&ds_KeyInfoType_qname);
606	0	if(result != GLOBUS_SUCCESS)
607		{
608	0	result = GlobusSoapMessageErrorSerializeFailed(
609		result, NULL, element_qname);
610	0	goto exit;
611		}
612
613	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
614		!globus_soap_message_serialize_is_c14n_subset(message_handle))
615		{
616	0	xsd_QName_init(&type_attr);
617
618	0	type_attr->local = globus_libc_strdup("type");
619	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
620		}
621
622	0	if (instance == NULL || (options & GLOBUS_XSD_ELEMENT_NIL))
623		{
624	0	xsd_QName_init(&nil_attr);
625
626	0	nil_attr->local = globus_libc_strdup("nil");
627	0	nil_attr->Namespace = globus_libc_strdup(XSI_NS);
628		}
629
630
631		/* serialize namespaces */
632	0	result = globus_soap_message_element_ns_add(
633		message_handle,
634		element_qname,
635		element_qname->Namespace,
636		&options);
637	0	if(result != GLOBUS_SUCCESS)
638		{
639	0	result = GlobusSoapMessageErrorSerializeFailed(
640		result, NULL, element_qname);
641	0	goto exit;
642		}
643
644	0	if(instance->_Id)
645		{
646
647	0	result = globus_soap_message_attribute_ns_add(
648		message_handle,
649		element_qname,
650		NULL,
651		&options);
652
653	0	if(result != GLOBUS_SUCCESS)
654		{
655	0	xsd_QName               error_qname;
656	0	error_qname.local = prefix;
657	0	error_qname.Namespace = "";
658	0	result = GlobusSoapMessageErrorSerializeFailed(result,
659		NULL,
660		&error_qname);
661	0	goto exit;
662		}
663
664
665		}
666
667	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
668		!globus_soap_message_serialize_is_c14n_subset(message_handle))
669		|| (instance == NULL || (options & GLOBUS_XSD_ELEMENT_NIL)))
670		{
671	0	result = globus_soap_message_attribute_ns_add(
672		message_handle,
673		element_qname,
674		"http://www.w3.org/2001/XMLSchema-instance",
675		&options);
676	0	if(result != GLOBUS_SUCCESS)
677		{
678	0	result = GlobusSoapMessageErrorSerializeFailed(
679		result, NULL, element_qname);
680	0	goto exit;
681		}
682		}
683	0	if ((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
684		!globus_soap_message_serialize_is_c14n_subset(message_handle))
685		{
686
687	0	result = globus_soap_message_attribute_ns_add(
688		message_handle,
689		element_qname,
690		ds_KeyInfoType_qname.Namespace,
691		&options);
692	0	if(result != GLOBUS_SUCCESS)
693		{
694	0	result = GlobusSoapMessageErrorSerializeFailed(
695		result, NULL, element_qname);
696	0	goto exit;
697		}
698		}
699
700		/* serialize attributes */
701
702	0	subelement.Namespace = "";
703	0	subelement.local = "Id";
704
705	0	if(instance->_Id)
706		{
707
708	0	result = xsd_ID_serialize_attribute(
709		&subelement,
710		instance->_Id,
711		message_handle,
712		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
713	0	if(result != GLOBUS_SUCCESS)
714		{
715	0	result = GlobusSoapMessageErrorSerializeFailed(result,
716		NULL,
717		element_qname);
718	0	goto exit;
719		}
720
721		}
722
723	0	if(instance == NULL || (options & GLOBUS_XSD_ELEMENT_NIL))
724		{
725	0	xsd_boolean nil = 1;
726
727	0	result = globus_soap_message_serialize_boolean_attribute(
728		message_handle,
729		nil_attr,
730		&nil);
731	0	if(result != GLOBUS_SUCCESS)
732		{
733	0	result = GlobusSoapMessageErrorSerializeFailed(
734		result, NULL, element_qname);
735	0	goto exit;
736		}
737		}
738
739	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
740		!globus_soap_message_serialize_is_c14n_subset(message_handle))
741		{
742	0	result = globus_soap_message_serialize_QName_attribute(
743		message_handle,
744		type_attr,
745		&ds_KeyInfoType_qname);
746	0	if(result != GLOBUS_SUCCESS)
747		{
748	0	result = GlobusSoapMessageErrorSerializeFailed(
749		result, NULL, element_qname);
750	0	goto exit;
751		}
752		}
753
754
755		}
756
757	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
758		{
759	0	result = globus_soap_message_serialize_element_begin_close(
760		message_handle, element_qname);
761	0	if(result != GLOBUS_SUCCESS)
762		{
763	0	result = GlobusSoapMessageErrorSerializeFailed(
764		result, NULL, element_qname);
765	0	goto exit;
766		}
767		}
768	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
769
770
771	0	if (instance != NULL && !(options & GLOBUS_XSD_ELEMENT_NIL))
772		{
773
774		/* serialize contents of type */
775
776	0	subelement.local = "choice_value";
777	0	subelement.Namespace = NULL;
778
779	0	result = GlobusXSDArrayCheckLowerBounds(
780		1,
781		instance->choice_value.length,
782		"choice_value");
783	0	if(result != GLOBUS_SUCCESS)
784		{
785	0	result = GlobusSoapMessageErrorSerializeFailed(
786		result, NULL, &ds_KeyInfoType_choice_qname);
787	0	goto exit;
788		}
789
790	0	result = ds_KeyInfoType_choice_array_serialize(
791		&subelement,
792		&instance->choice_value,
793		message_handle,
794		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
795	0	if(result != GLOBUS_SUCCESS)
796		{
797	0	result = GlobusSoapMessageErrorSerializeFailed(
798		result, NULL, &ds_KeyInfoType_choice_qname);
799	0	goto exit;
800		}
801
802		}
803
804	0	options = save_options;
805
806	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
807		{
808		/* add end element */
809	0	result = globus_soap_message_serialize_element_end(
810		message_handle,
811		element_qname,
812		options,
813		&ds_KeyInfoType_qname);
814	0	if(result != GLOBUS_SUCCESS)
815		{
816	0	result = GlobusSoapMessageErrorSerializeFailed(
817		result, NULL, element_qname);
818	0	goto exit;
819		}
820
821	0	globus_soap_message_element_ns_remove(
822		message_handle,
823		element_qname->Namespace,
824		&options);
825
826		/* remove namespace/prefix mappings for these types */
827
828	0	if(instance->_Id)
829		{
830
831	0	globus_soap_message_attribute_ns_remove(
832		message_handle,
833		NULL,
834		&options);
835
836		}
837
838	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
839		!globus_soap_message_serialize_is_c14n_subset(message_handle))
840		|| (instance == NULL || (options & GLOBUS_XSD_ELEMENT_NIL)))
841		{
842	0	globus_soap_message_attribute_ns_remove(
843		message_handle,
844		"http://www.w3.org/2001/XMLSchema-instance",
845		&options);
846		}
847	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
848		!globus_soap_message_serialize_is_c14n_subset(message_handle))
849		{
850	0	globus_soap_message_attribute_ns_remove(
851		message_handle,
852		ds_KeyInfoType_qname.Namespace,
853		&options);
854		}
855
856		}
857
858		exit:
859	0	if (type_attr)
860		{
861	0	xsd_QName_destroy(type_attr);
862		}
863
864	0	if (nil_attr)
865		{
866	0	xsd_QName_destroy(nil_attr);
867		}
868
869
870	0	if(any_attr_keys)
871		{
872	0	globus_list_free(any_attr_keys);
873		}
874
875	0	GlobusSoapMessageDebugExit();
876	0	return result;
877		}
878
879
880
881		globus_result_t
882		ds_KeyInfoType_deserialize_contents(
883		const xsd_QName *                   element_qname, /* ignored */
884		ds_KeyInfoType *                    inst,
885		globus_soap_message_handle_t        message_handle,
886		globus_xsd_element_options_t        options)
887	0	{
888	0	globus_result_t                     result = GLOBUS_SUCCESS;
889	0	GlobusFuncName(ds_KeyInfoType_deserialize_contents);
890	0	GlobusSoapMessageDebugEnter();
891
892	0	result = ds_KeyInfoType_deserialize(
893		NULL,
894		inst,
895		message_handle,
896		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
897	0	if(result != GLOBUS_SUCCESS)
898		{
899	0	result = GlobusSoapMessageErrorDeserializeFailed(
900		result, element_qname);
901		goto exit;
902		}
903
904		exit:
905
906	0	GlobusSoapMessageDebugExit();
907	0	return result;
908		}
909
910
911
912		globus_result_t
913		ds_KeyInfoType_deserialize(
914		const xsd_QName *                   element_qname,
915		ds_KeyInfoType *                    instance,
916		globus_soap_message_handle_t        message_handle,
917		globus_xsd_element_options_t        options)
918	0	{
919	0	globus_result_t                     result = GLOBUS_SUCCESS;
920	0	xsd_QName                           subelement;
921	0	GlobusFuncName(ds_KeyInfoType_deserialize);
922	0	GlobusSoapMessageDebugEnter();
923
924
925	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
926		{
927	0	result = globus_soap_message_deserialize_element(
928		message_handle, element_qname);
929	0	if(result != GLOBUS_SUCCESS)
930		{
931	0	result = GlobusSoapMessageErrorDeserializeFailed(
932		result, element_qname);
933	0	goto exit;
934		}
935
936	0	subelement.Namespace = "";
937	0	subelement.local = "Id";
938
939	0	result = xsd_ID_deserialize_attribute_pointer(
940		&subelement,
941		&instance->_Id,
942		message_handle,
943		0);
944	0	if(result != GLOBUS_SUCCESS)
945		{
946	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
947	0	goto _Id_destroy;
948		}
949
950
951
952	0	result = globus_soap_message_deserialize_element_begin_close(
953		message_handle);
954	0	if(result != GLOBUS_SUCCESS)
955		{
956	0	result = GlobusSoapMessageErrorDeserializeFailed(
957		result, element_qname);
958	0	goto fail_deserialize;
959		}
960		}
961
962	0	subelement.local = "choice_value";
963	0	subelement.Namespace = NULL;
964
965	0	result = ds_KeyInfoType_choice_array_deserialize(
966		&subelement,
967		&instance->choice_value,
968		message_handle,
969		0);
970	0	if(result != GLOBUS_SUCCESS)
971		{
972	0	result = GlobusSoapMessageErrorDeserializeFailed(
973		result,
974		(&subelement));
975	0	goto choice_value_destroy_array;
976		}
977
978	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
979		{
980	0	result = globus_soap_message_deserialize_element_end(
981		message_handle,
982		element_qname);
983	0	if(result != GLOBUS_SUCCESS)
984		{
985	0	result = GlobusSoapMessageErrorDeserializeFailed(
986		result, element_qname);
987		goto fail_deserialize;
988		}
989		}
990
991	0	goto exit;
992
993		fail_deserialize:
994
995		_Id_destroy:
996		/* output_fail_destroy_attribute() */
997
998	0	if(instance->_Id)
999		{
1000	0	xsd_ID_destroy(
1001		instance->_Id);
1002	0	instance->_Id = NULL;
1003		}
1004	0	ds_KeyInfoType_choice_array_destroy_contents(
1005		&instance->choice_value);
1006
1007		choice_value_destroy_array:
1008
1009
1010		exit:
1011
1012	0	GlobusSoapMessageDebugExit();
1013	0	return result;
1014		}
1015
1016
1017
1018		globus_result_t
1019		ds_KeyInfoType_deserialize_pointer(
1020		const xsd_QName *                   element_qname,
1021		ds_KeyInfoType **                   ip,
1022		globus_soap_message_handle_t        message_handle,
1023		globus_xsd_element_options_t        options)
1024	0	{
1025	0	ds_KeyInfoType * instance = NULL;
1026	0	globus_result_t                     result = GLOBUS_SUCCESS;
1027	0	xsd_QName                           subelement;
1028	0	int                                 found_attrs = 0;
1029	0	int                                 empty_element = 0;
1030	0	GlobusFuncName(ds_KeyInfoType_deserialize_pointer);
1031	0	GlobusSoapMessageDebugEnter();
1032
1033	0	*ip = NULL;
1034
1035	0	result = globus_soap_message_deserialize_element(
1036		message_handle, element_qname);
1037	0	if(result != GLOBUS_SUCCESS &&
1038		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1039		GlobusSoapMessageStatusFailedElementCheck(result) ||
1040		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1041		{
1042	0	result = GLOBUS_SUCCESS;
1043	0	goto exit;
1044		}
1045
1046	0	if(result != GLOBUS_SUCCESS)
1047		{
1048	0	result = GlobusSoapMessageErrorDeserializeFailed(
1049		result, element_qname);
1050	0	goto exit;
1051		}
1052
1053	0	if(globus_soap_message_deserialize_element_is_empty(
1054		message_handle))
1055		{
1056	0	empty_element = 1;
1057		}
1058
1059	0	result = ds_KeyInfoType_init(&instance);
1060	0	if(result != GLOBUS_SUCCESS)
1061		{
1062	0	result = GlobusSoapMessageErrorDeserializeFailed(
1063		result, element_qname);
1064	0	goto exit;
1065		}
1066
1067
1068	0	subelement.Namespace = "";
1069	0	subelement.local = "Id";
1070
1071	0	result = xsd_ID_deserialize_attribute_pointer(
1072		&subelement,
1073		&instance->_Id,
1074		message_handle,
1075		0);
1076	0	if(result != GLOBUS_SUCCESS)
1077		{
1078	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1079	0	goto _Id_destroy;
1080		}
1081
1082
1083	0	if(instance->_Id)
1084		{
1085	0	found_attrs++;
1086		}
1087
1088	0	if(found_attrs == 0 &&
1089		globus_soap_message_deserialize_element_is_nil(message_handle))
1090		{
1091	0	ds_KeyInfoType_destroy(instance);
1092
1093	0	result = globus_soap_message_deserialize_element_end(
1094		message_handle,
1095		element_qname);
1096	0	if(result != GLOBUS_SUCCESS)
1097		{
1098	0	result = GlobusSoapMessageErrorDeserializeFailed(
1099		result, element_qname);
1100	0	goto exit;
1101		}
1102
1103	0	*ip = NULL;
1104	0	globus_object_free(globus_error_get(result));
1105	0	result = GLOBUS_SUCCESS;
1106	0	goto exit;
1107		}
1108
1109
1110	0	if(empty_element)
1111		{
1112	0	result = globus_soap_message_deserialize_element_end(
1113		message_handle,
1114		element_qname);
1115	0	if(result != GLOBUS_SUCCESS)
1116		{
1117	0	result = GlobusSoapMessageErrorDeserializeFailed(
1118		result, element_qname);
1119	0	goto fail_deserialize;
1120		}
1121
1122	0	*ip = instance;
1123	0	goto exit;
1124		}
1125
1126	0	result = globus_soap_message_deserialize_element_begin_close(
1127		message_handle);
1128	0	if(result != GLOBUS_SUCCESS)
1129		{
1130	0	result = GlobusSoapMessageErrorDeserializeFailed(
1131		result, element_qname);
1132	0	goto exit;
1133		}
1134
1135	0	result = ds_KeyInfoType_deserialize(
1136		element_qname,
1137		instance,
1138		message_handle,
1139		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1140
1141	0	result = globus_soap_message_deserialize_element_end(
1142		message_handle,
1143		element_qname);
1144	0	if(result != GLOBUS_SUCCESS)
1145		{
1146	0	result = GlobusSoapMessageErrorDeserializeFailed(
1147		result, element_qname);
1148	0	goto fail_deserialize;
1149		}
1150
1151	0	*ip = instance;
1152
1153	0	goto exit;
1154
1155		fail_deserialize:
1156
1157		_Id_destroy:
1158		/* output_fail_destroy_attribute() */
1159
1160	0	if(instance->_Id)
1161		{
1162	0	xsd_ID_destroy(
1163		instance->_Id);
1164	0	instance->_Id = NULL;
1165		}
1166	0	ds_KeyInfoType_choice_array_destroy_contents(
1167		&instance->choice_value);
1168
1169		choice_value_destroy_array:
1170
1171		exit:
1172
1173	0	GlobusSoapMessageDebugExit();
1174	0	return result;
1175		}
1176
1177
1178		globus_result_t
1179		ds_KeyInfoType_array_init_contents(
1180		ds_KeyInfoType_array * array)
1181	0	{
1182	0	return globus_xsd_generic_array_init_contents(
1183		(globus_xsd_generic_array_t *) array,
1184		&ds_KeyInfoType_info);
1185		}
1186		/* ds_KeyInfoType_array_init_contents() */
1187
1188		globus_result_t
1189		ds_KeyInfoType_array_init(
1190		ds_KeyInfoType_array ** arr)
1191	0	{
1192	0	return globus_xsd_generic_array_init(
1193		(globus_xsd_generic_array_t **) arr,
1194		&ds_KeyInfoType_info);
1195		}
1196		/* ds_KeyInfoType_array_init() */
1197
1198		void
1199		ds_KeyInfoType_array_destroy_contents(
1200		ds_KeyInfoType_array * array)
1201	0	{
1202	0	globus_xsd_generic_array_destroy_contents(
1203		(globus_xsd_generic_array_t *) array);
1204		}
1205		/* ds_KeyInfoType_array_destroy_contents() */
1206
1207		void
1208		ds_KeyInfoType_array_destroy(
1209		ds_KeyInfoType_array * array)
1210	0	{
1211	0	globus_xsd_generic_array_destroy(
1212		(globus_xsd_generic_array_t *) array);
1213		}
1214		/* ds_KeyInfoType_array_destroy() */
1215
1216		globus_result_t
1217		ds_KeyInfoType_array_copy(
1218		ds_KeyInfoType_array ** dest_arr,
1219		const ds_KeyInfoType_array * src_arr)
1220	0	{
1221	0	return globus_xsd_generic_array_copy(
1222		(globus_xsd_generic_array_t **) dest_arr,
1223		(globus_xsd_generic_array_t *) src_arr);
1224		}
1225		/* ds_KeyInfoType_array_copy() */
1226
1227		globus_result_t
1228		ds_KeyInfoType_array_copy_contents(
1229		ds_KeyInfoType_array * dest_arr,
1230		const ds_KeyInfoType_array * src_arr)
1231	0	{
1232	0	return globus_xsd_generic_array_copy_contents(
1233		(globus_xsd_generic_array_t *) dest_arr,
1234		(globus_xsd_generic_array_t *) src_arr);
1235		}
1236		/* ds_KeyInfoType_array_copy_contents() */
1237
1238		ds_KeyInfoType *
1239		ds_KeyInfoType_array_push(
1240		ds_KeyInfoType_array * array)
1241	0	{
1242		/* Some contents initializers don't initialize subelments but to set their
1243		* values to be NULL
1244		*/
1245	0	if (array->type_info == NULL)
1246		{
1247	0	array->type_info = &ds_KeyInfoType_info;
1248		}
1249
1250	0	return globus_xsd_generic_array_push(
1251		(globus_xsd_generic_array_t *) array);
1252		}
1253		/* ds_KeyInfoType_array_push() */
1254
1255		void *
1256		ds_KeyInfoType_array_push_wrapper(
1257		void * array)
1258	0	{
1259	0	return (void *) ds_KeyInfoType_array_push((ds_KeyInfoType_array *) array);
1260		}
1261
1262		globus_result_t
1263		ds_KeyInfoType_array_serialize(
1264		const xsd_QName *                   element_qname,
1265		const ds_KeyInfoType_array *        array,
1266		globus_soap_message_handle_t        message,
1267		globus_xsd_element_options_t        options)
1268	0	{
1269	0	return globus_xsd_generic_array_serialize(
1270		element_qname,
1271		(const globus_xsd_generic_array_t *) array,
1272		message,
1273		options);
1274		}
1275		/* ds_KeyInfoType_array_serialize() */
1276
1277		globus_result_t
1278		ds_KeyInfoType_array_deserialize(
1279		const xsd_QName *                   element_qname,
1280		ds_KeyInfoType_array * array,
1281		globus_soap_message_handle_t        message,
1282		globus_xsd_element_options_t        options)
1283	0	{
1284		/* Some initializers set the array's contents to NULL */
1285	0	if (array->type_info == NULL)
1286		{
1287	0	array->type_info = &ds_KeyInfoType_info;
1288		}
1289	0	return globus_xsd_generic_array_deserialize(
1290		element_qname,
1291		(globus_xsd_generic_array_t *) array,
1292		message,
1293		options);