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_ReferenceType.h"
21
22		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
23		xsd_QName ds_ReferenceType_qname =
24		{
25		DS_REFERENCETYPE_NS,
26		DS_REFERENCETYPE_LOCAL
27		};
28		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
29
30		globus_result_t
31		ds_ReferenceType_serialize_wrapper(
32		xsd_QName *                         element_qname,
33		void *                              instance,
34		globus_soap_message_handle_t        message_handle,
35		globus_xsd_element_options_t        options)
36	0	{
37	0	return ds_ReferenceType_serialize(
38		element_qname,
39		(ds_ReferenceType *) instance,
40		message_handle, options);
41		}
42
43		globus_result_t
44		ds_ReferenceType_deserialize_pointer_wrapper(
45		xsd_QName *                         element_qname,
46		void **                             ip,
47		globus_soap_message_handle_t        message_handle,
48		globus_xsd_element_options_t        options)
49	0	{
50	0	return ds_ReferenceType_deserialize_pointer(
51		element_qname,
52		(ds_ReferenceType **) ip,
53		message_handle, options);
54		}
55
56		globus_result_t
57		ds_ReferenceType_init_wrapper(void **object)
58	0	{
59	0	return ds_ReferenceType_init(
60		(ds_ReferenceType **) object);
61		}
62
63		void
64		ds_ReferenceType_destroy_wrapper(
65		void *                          object)
66	0	{
67	0	ds_ReferenceType_destroy(
68		(ds_ReferenceType *) object);
69		}
70
71		globus_result_t
72		ds_ReferenceType_copy_wrapper(
73		void **                         dest_obj,
74		void *                          src_obj)
75	0	{
76	0	return ds_ReferenceType_copy(
77		(ds_ReferenceType **) dest_obj,
78		(ds_ReferenceType *) src_obj);
79		}
80
81		globus_result_t
82		ds_ReferenceType_init_contents_wrapper(void *object)
83	0	{
84	0	return ds_ReferenceType_init_contents(
85		(ds_ReferenceType *) object);
86		}
87
88		void
89		ds_ReferenceType_destroy_contents_wrapper(
90		void *                          object)
91	0	{
92	0	ds_ReferenceType_destroy_contents(
93		(ds_ReferenceType *) object);
94		}
95
96		globus_result_t
97		ds_ReferenceType_copy_contents_wrapper(
98		void *                          dest_obj,
99		void *                          src_obj)
100	0	{
101	0	return ds_ReferenceType_copy_contents(
102		(ds_ReferenceType *) dest_obj,
103		(ds_ReferenceType *) src_obj);
104		}
105
106		globus_result_t
107		ds_ReferenceType_serialize_contents_wrapper(
108		xsd_QName *                         element_qname,
109		void *                              instance,
110		globus_soap_message_handle_t        message_handle,
111		globus_xsd_element_options_t        options)
112	0	{
113	0	return ds_ReferenceType_serialize_contents(
114		element_qname,
115		(ds_ReferenceType *) instance,
116		message_handle, options);
117		}
118
119		globus_result_t
120		ds_ReferenceType_deserialize_contents_wrapper(
121		xsd_QName *                         element_qname,
122		void **                             instance,
123		globus_soap_message_handle_t        message_handle,
124		globus_xsd_element_options_t        options)
125	0	{
126	0	globus_result_t                     result;
127	0	GlobusFuncName(ds_ReferenceType_deserialize_contents_wrapper);
128	0	GlobusSoapMessageDebugEnter();
129
130	0	if(!*instance)
131		{
132	0	result = ds_ReferenceType_init(
133		(ds_ReferenceType **)instance);
134	0	if(result != GLOBUS_SUCCESS)
135		{
136	0	goto error;
137		}
138		}
139
140	0	result = ds_ReferenceType_deserialize_contents(
141		element_qname,
142		*(ds_ReferenceType **)instance,
143		message_handle, options);
144		error:
145	0	GlobusSoapMessageDebugExit();
146	0	return result;
147		}
148
149		globus_result_t
150		ds_ReferenceType_array_serialize_wrapper(
151		xsd_QName *                     element,
152		void *                          instance,
153		globus_soap_message_handle_t    message,
154		globus_xsd_element_options_t    options)
155	0	{
156	0	return ds_ReferenceType_array_serialize(
157		element,
158		(ds_ReferenceType_array *) instance,
159		message, options);
160		}
161
162		globus_result_t
163		ds_ReferenceType_array_deserialize_wrapper(
164		xsd_QName *                         element_qname,
165		void **                             inst,
166		globus_soap_message_handle_t        message,
167		globus_xsd_element_options_t        options)
168	0	{
169	0	if(!*inst)
170		{
171	0	globus_result_t                 result;
172
173	0	result = ds_ReferenceType_array_init(
174		(ds_ReferenceType_array **)inst);
175	0	if(result != GLOBUS_SUCCESS)
176		{
177	0	return result;
178		}
179		}
180
181	0	return ds_ReferenceType_array_deserialize(
182		element_qname,
183		*(ds_ReferenceType_array **) inst,
184		message, options);
185		}
186
187		globus_result_t
188		ds_ReferenceType_array_init_wrapper(
189		void **                             arr)
190	0	{
191	0	return ds_ReferenceType_array_init(
192		(ds_ReferenceType_array **) arr);
193		}
194
195		void
196		ds_ReferenceType_array_destroy_wrapper(
197		void *                              arr)
198	0	{
199	0	ds_ReferenceType_array_destroy(
200		(ds_ReferenceType_array *) arr);
201		}
202
203		globus_result_t
204		ds_ReferenceType_array_copy_wrapper(
205		void **                             dest_arr,
206		void *                              src_arr)
207	0	{
208	0	return ds_ReferenceType_array_copy(
209		(ds_ReferenceType_array **) dest_arr,
210		(ds_ReferenceType_array *) src_arr);
211		}
212
213		globus_result_t
214		ds_ReferenceType_array_init_contents_wrapper(
215		void *                              arr)
216	0	{
217	0	return ds_ReferenceType_array_init_contents(
218		(ds_ReferenceType_array *) arr);
219		}
220
221		void
222		ds_ReferenceType_array_destroy_contents_wrapper(
223		void *                              arr)
224	0	{
225	0	ds_ReferenceType_array_destroy_contents(
226		(ds_ReferenceType_array *) arr);
227		}
228
229		globus_result_t
230		ds_ReferenceType_array_copy_contents_wrapper(
231		void *                              dest_arr,
232		void *                              src_arr)
233	0	{
234	0	return ds_ReferenceType_array_copy_contents(
235		(ds_ReferenceType_array *) dest_arr,
236		(ds_ReferenceType_array *) src_arr);
237		}
238
239		struct globus_xsd_type_info_s ds_ReferenceType_contents_info =
240		{
241		&ds_ReferenceType_qname,
242		ds_ReferenceType_serialize_contents_wrapper,
243		ds_ReferenceType_deserialize_contents_wrapper,
244		ds_ReferenceType_init_wrapper,
245		ds_ReferenceType_destroy_wrapper,
246		ds_ReferenceType_copy_wrapper,
247		ds_ReferenceType_init_contents_wrapper,
248		ds_ReferenceType_destroy_contents_wrapper,
249		ds_ReferenceType_copy_contents_wrapper,
250		sizeof(ds_ReferenceType),
251		NULL,
252		NULL,
253		NULL
254		};
255
256		struct globus_xsd_type_info_s ds_ReferenceType_array_info =
257		{
258		&ds_ReferenceType_qname,
259		ds_ReferenceType_array_serialize_wrapper,
260		ds_ReferenceType_array_deserialize_wrapper,
261		ds_ReferenceType_array_init_wrapper,
262		ds_ReferenceType_array_destroy_wrapper,
263		ds_ReferenceType_array_copy_wrapper,
264		ds_ReferenceType_array_init_contents_wrapper,
265		ds_ReferenceType_array_destroy_contents_wrapper,
266		ds_ReferenceType_array_copy_contents_wrapper,
267		sizeof(ds_ReferenceType),
268		ds_ReferenceType_array_push_wrapper,
269		NULL,
270		NULL
271		};
272
273		struct globus_xsd_type_info_s ds_ReferenceType_info =
274		{
275		&ds_ReferenceType_qname,
276		ds_ReferenceType_serialize_wrapper,
277		ds_ReferenceType_deserialize_pointer_wrapper,
278		ds_ReferenceType_init_wrapper,
279		ds_ReferenceType_destroy_wrapper,
280		ds_ReferenceType_copy_wrapper,
281		ds_ReferenceType_init_contents_wrapper,
282		ds_ReferenceType_destroy_contents_wrapper,
283		ds_ReferenceType_copy_contents_wrapper,
284		sizeof(ds_ReferenceType),
285		NULL,
286		&ds_ReferenceType_contents_info,
287		&ds_ReferenceType_array_info
288		};
289
290		globus_result_t
291		ds_ReferenceType_init_contents(
292		ds_ReferenceType * instance)
293	0	{
294	0	globus_result_t                     result = GLOBUS_SUCCESS;
295	0	GlobusFuncName(ds_ReferenceType_init_contents);
296	0	GlobusSoapMessageDebugEnter();
297
298	0	memset(instance, 0, sizeof(ds_ReferenceType));
299
300	0	GlobusSoapMessageDebugExit();
301	0	return result;
302		}
303
304		globus_result_t
305		ds_ReferenceType_init(
306		ds_ReferenceType ** object)
307	0	{
308	0	ds_ReferenceType * instance;
309	0	globus_result_t                     result = GLOBUS_SUCCESS;
310	0	GlobusFuncName(ds_ReferenceType_init);
311	0	GlobusSoapMessageDebugEnter();
312
313	0	instance = globus_malloc(sizeof(ds_ReferenceType));
314	0	if(!instance)
315		{
316	0	result = GlobusSoapMessageErrorOutOfMemory;
317	0	goto exit;
318		}
319
320	0	memset(instance, 0, sizeof(ds_ReferenceType));
321
322	0	*object = instance;
323
324		exit:
325	0	GlobusSoapMessageDebugExit();
326	0	return result;
327		}
328
329		void
330		ds_ReferenceType_destroy(
331		ds_ReferenceType * instance)
332	0	{
333	0	GlobusFuncName(ds_ReferenceType_destroy);
334	0	GlobusSoapMessageDebugEnter();
335
336	0	if(!instance)
337		{
338	0	goto exit;
339		}
340
341	0	ds_ReferenceType_destroy_contents(instance);
342	0	globus_free(instance);
343
344		exit:
345
346	0	GlobusSoapMessageDebugExit();
347		}
348
349		void
350		ds_ReferenceType_destroy_contents(
351		ds_ReferenceType * instance)
352	0	{
353	0	GlobusFuncName(ds_ReferenceType_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	if(instance)
357		{
358
359
360	0	ds_TransformsType_destroy(instance->Transforms);
361	0	instance->Transforms = NULL;
362
363	0	ds_DigestMethodType_destroy_contents(
364		&instance->DigestMethod);
365
366	0	ds_DigestValueType_destroy_contents(
367		&instance->DigestValue);
368
369	0	if(instance->_Id)
370		{
371	0	xsd_ID_destroy(
372		instance->_Id);
373	0	instance->_Id = NULL;
374		}
375
376	0	if(instance->_Type)
377		{
378	0	xsd_anyURI_destroy(
379		instance->_Type);
380	0	instance->_Type = NULL;
381		}
382
383	0	if(instance->_URI)
384		{
385	0	xsd_anyURI_destroy(
386		instance->_URI);
387	0	instance->_URI = NULL;
388		}
389
390		}
391
392	0	GlobusSoapMessageDebugExit();
393		}
394
395		globus_result_t
396		ds_ReferenceType_copy(
397		ds_ReferenceType ** dest_obj,
398		const ds_ReferenceType * src_obj)
399	0	{
400	0	globus_result_t                     result = GLOBUS_SUCCESS;
401	0	ds_ReferenceType * instance;
402	0	GlobusFuncName(ds_ReferenceType_copy);
403
404	0	GlobusSoapMessageDebugEnter();
405
406	0	instance = malloc(sizeof(ds_ReferenceType));
407	0	if (instance == NULL)
408		{
409	0	GlobusSoapMessageDebugExit();
410	0	return GlobusSoapMessageErrorOutOfMemory;
411		}
412
413	0	result = ds_ReferenceType_copy_contents(instance, src_obj);
414	0	if(result != GLOBUS_SUCCESS)
415		{
416	0	globus_free(instance);
417	0	GlobusSoapMessageDebugExit();
418	0	return GlobusSoapMessageErrorOutOfMemory;
419		}
420
421	0	*dest_obj = instance;
422	0	GlobusSoapMessageDebugExit();
423	0	return result;
424		}
425
426		globus_result_t
427		ds_ReferenceType_copy_contents(
428		ds_ReferenceType * instance,
429		const ds_ReferenceType * src_obj)
430	0	{
431	0	globus_result_t                     result = GLOBUS_SUCCESS;
432	0	GlobusFuncName(ds_ReferenceType_copy_contents);
433
434	0	GlobusSoapMessageDebugEnter();
435
436
437	0	if(src_obj->_Id)
438		{
439	0	result = xsd_ID_copy(
440		&instance->_Id,
441		src_obj->_Id);
442	0	if(result != GLOBUS_SUCCESS)
443		{
444	0	result = GlobusSoapMessageErrorCopyFailed(
445		result, NULL, &xsd_ID_qname);
446	0	goto _Id_destroy;
447		}
448		}
449		else
450		{
451	0	instance->_Id = NULL;
452		}
453
454	0	if(src_obj->_Type)
455		{
456	0	result = xsd_anyURI_copy(
457		&instance->_Type,
458		src_obj->_Type);
459	0	if(result != GLOBUS_SUCCESS)
460		{
461	0	result = GlobusSoapMessageErrorCopyFailed(
462		result, NULL, &xsd_anyURI_qname);
463	0	goto _Type_destroy;
464		}
465		}
466		else
467		{
468	0	instance->_Type = NULL;
469		}
470
471	0	if(src_obj->_URI)
472		{
473	0	result = xsd_anyURI_copy(
474		&instance->_URI,
475		src_obj->_URI);
476	0	if(result != GLOBUS_SUCCESS)
477		{
478	0	result = GlobusSoapMessageErrorCopyFailed(
479		result, NULL, &xsd_anyURI_qname);
480	0	goto _URI_destroy;
481		}
482		}
483		else
484		{
485	0	instance->_URI = NULL;
486		}
487
488	0	if(src_obj->Transforms)
489		{
490	0	result = ds_TransformsType_copy(
491		&instance->Transforms,
492		src_obj->Transforms);
493	0	if(result != GLOBUS_SUCCESS)
494		{
495	0	result = GlobusSoapMessageErrorCopyFailed(
496		result, NULL, &ds_TransformsType_qname);
497	0	goto Transforms_destroy_pointer;
498		}
499		}
500		else
501		{
502	0	instance->Transforms = NULL;
503		}
504
505	0	result = ds_DigestMethodType_copy_contents(
506		&instance->DigestMethod,
507		&src_obj->DigestMethod);
508	0	if(result != GLOBUS_SUCCESS)
509		{
510	0	result = GlobusSoapMessageErrorCopyFailed(
511		result, NULL, &ds_DigestMethodType_qname);
512	0	goto DigestMethod_destroy;
513		}
514
515	0	result = ds_DigestValueType_copy_contents(
516		&instance->DigestValue,
517		&src_obj->DigestValue);
518	0	if(result != GLOBUS_SUCCESS)
519		{
520	0	result = GlobusSoapMessageErrorCopyFailed(
521		result, NULL, &ds_DigestValueType_qname);
522	0	goto DigestValue_destroy;
523		}
524
525	0	goto exit;
526
527		fail_deserialize:
528
529		_Id_destroy:
530
531	0	if(instance->_Id)
532		{
533	0	xsd_ID_destroy(
534		instance->_Id);
535	0	instance->_Id = NULL;
536		}
537
538		_Type_destroy:
539
540	0	if(instance->_Type)
541		{
542	0	xsd_anyURI_destroy(
543		instance->_Type);
544	0	instance->_Type = NULL;
545		}
546
547		_URI_destroy:
548
549	0	if(instance->_URI)
550		{
551	0	xsd_anyURI_destroy(
552		instance->_URI);
553	0	instance->_URI = NULL;
554		}
555	0	ds_DigestValueType_destroy_contents(
556		&instance->DigestValue);
557
558		DigestValue_destroy:
559	0	ds_DigestMethodType_destroy_contents(
560		&instance->DigestMethod);
561
562		DigestMethod_destroy:
563	0	ds_TransformsType_destroy(
564		instance->Transforms);
565	0	instance->Transforms = NULL;
566
567		Transforms_destroy_pointer:
568
569
570		exit:
571
572	0	GlobusSoapMessageDebugExit();
573	0	return result;
574		}
575
576
577
578		globus_result_t
579		ds_ReferenceType_serialize_contents(
580		xsd_QName *                         element_qname, /* ignored */
581		ds_ReferenceType * inst,
582		globus_soap_message_handle_t        message_handle,
583		globus_xsd_element_options_t        options)
584	0	{
585	0	globus_result_t                     result = GLOBUS_SUCCESS;
586	0	GlobusFuncName(ds_ReferenceType_serialize_contents);
587	0	GlobusSoapMessageDebugEnter();
588
589	0	result = ds_ReferenceType_serialize(
590		NULL,
591		inst,
592		message_handle,
593		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
594	0	if(result != GLOBUS_SUCCESS)
595		{
596	0	result = GlobusSoapMessageErrorSerializeFailed(
597		result, NULL, element_qname);
598		goto exit;
599		}
600
601		exit:
602
603	0	GlobusSoapMessageDebugExit();
604	0	return result;
605		}
606
607
608
609		globus_result_t
610		ds_ReferenceType_serialize(
611		xsd_QName *                         element_qname,
612		ds_ReferenceType * instance,
613		globus_soap_message_handle_t        message_handle,
614		globus_xsd_element_options_t        options)
615	0	{
616	0	globus_result_t                     result = GLOBUS_SUCCESS;
617	0	xsd_QName                           subelement;
618	0	globus_list_t *                     any_attr_keys = NULL;
619	0	globus_list_t *                     any_attr_keys_iterator = NULL;
620	0	xsd_QName *                         type_attr = NULL;
621	0	char *                              prefix = NULL;
622	0	int                                 prefix_created;
623	0	int                                 define_prefix = 0;
624	0	int                                 save_options = options;
625
626	0	GlobusFuncName(ds_ReferenceType_serialize);
627	0	GlobusSoapMessageDebugEnter();
628
629
630	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
631		{
632		/* serialize ds_ReferenceType element */
633
634	0	result = globus_soap_message_invoke_ns_callouts(
635		message_handle,
636		element_qname,
637		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_SET,
638		&options);
639	0	if(result != GLOBUS_SUCCESS)
640		{
641	0	result = GlobusSoapMessageErrorSerializeFailed(
642		result, NULL, element_qname);
643	0	goto exit;
644		}
645
646	0	result = globus_soap_message_element_ns_set(
647		message_handle,
648		element_qname->Namespace,
649		&options);
650	0	if(result != GLOBUS_SUCCESS)
651		{
652	0	result = GlobusSoapMessageErrorSerializeFailed(
653		result, NULL, element_qname);
654	0	goto exit;
655		}
656
657	0	if(instance->_Id)
658		{
659
660	0	result = globus_soap_message_attribute_ns_set(
661		message_handle,
662		NULL,
663		&options);
664
665	0	if(result != GLOBUS_SUCCESS)
666		{
667	0	xsd_QName               error_qname;
668	0	error_qname.local = prefix;
669	0	error_qname.Namespace = "";
670	0	result = GlobusSoapMessageErrorSerializeFailed(result,
671		NULL,
672		&error_qname);
673	0	goto exit;
674		}
675
676
677		}
678
679	0	if(instance->_Type)
680		{
681
682	0	result = globus_soap_message_attribute_ns_set(
683		message_handle,
684		NULL,
685		&options);
686
687	0	if(result != GLOBUS_SUCCESS)
688		{
689	0	xsd_QName               error_qname;
690	0	error_qname.local = prefix;
691	0	error_qname.Namespace = "";
692	0	result = GlobusSoapMessageErrorSerializeFailed(result,
693		NULL,
694		&error_qname);
695	0	goto exit;
696		}
697
698
699		}
700
701	0	if(instance->_URI)
702		{
703
704	0	result = globus_soap_message_attribute_ns_set(
705		message_handle,
706		NULL,
707		&options);
708
709	0	if(result != GLOBUS_SUCCESS)
710		{
711	0	xsd_QName               error_qname;
712	0	error_qname.local = prefix;
713	0	error_qname.Namespace = "";
714	0	result = GlobusSoapMessageErrorSerializeFailed(result,
715		NULL,
716		&error_qname);
717	0	goto exit;
718		}
719
720
721		}
722
723	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
724		!globus_soap_message_serialize_is_c14n_subset(message_handle))
725		{
726	0	result = globus_soap_message_attribute_ns_set(
727		message_handle,
728		"http://www.w3.org/2001/XMLSchema-instance",
729		&options);
730	0	if(result != GLOBUS_SUCCESS)
731		{
732	0	result = GlobusSoapMessageErrorSerializeFailed(
733		result, NULL, element_qname);
734	0	goto exit;
735		}
736
737	0	result = globus_soap_message_attribute_ns_set(
738		message_handle,
739		ds_ReferenceType_qname.Namespace,
740		&options);
741	0	if(result != GLOBUS_SUCCESS)
742		{
743	0	result = GlobusSoapMessageErrorSerializeFailed(
744		result, NULL, element_qname);
745	0	goto exit;
746		}
747		}
748
749	0	result = globus_soap_message_invoke_callouts(
750		message_handle,
751		element_qname,
752		GLOBUS_SOAP_MESSAGE_CALLOUT_BEGIN);
753	0	if(result != GLOBUS_SUCCESS)
754		{
755	0	result = GlobusSoapMessageErrorSerializeFailed(
756		result, NULL, element_qname);
757	0	goto exit;
758		}
759
760	0	result = globus_soap_message_serialize_element(
761		message_handle,
762		element_qname,
763		options,
764		&ds_ReferenceType_qname);
765	0	if(result != GLOBUS_SUCCESS)
766		{
767	0	result = GlobusSoapMessageErrorSerializeFailed(
768		result, NULL, element_qname);
769	0	goto exit;
770		}
771
772	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
773		!globus_soap_message_serialize_is_c14n_subset(message_handle))
774		{
775	0	xsd_QName_init(&type_attr);
776
777	0	type_attr->local = globus_libc_strdup("type");
778	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
779		}
780
781		/* serialize namespaces */
782
783	0	result = globus_soap_message_invoke_ns_callouts(
784		message_handle,
785		element_qname,
786		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_ADD,
787		&options);
788	0	if(result != GLOBUS_SUCCESS)
789		{
790	0	result = GlobusSoapMessageErrorSerializeFailed(
791		result, NULL, element_qname);
792	0	goto exit;
793		}
794
795	0	result = globus_soap_message_element_ns_add(
796		message_handle,
797		element_qname->Namespace,
798		&options);
799	0	if(result != GLOBUS_SUCCESS)
800		{
801	0	result = GlobusSoapMessageErrorSerializeFailed(
802		result, NULL, element_qname);
803	0	goto exit;
804		}
805
806	0	if(instance->_Id)
807		{
808
809	0	result = globus_soap_message_attribute_ns_add(
810		message_handle,
811		NULL,
812		&options);
813
814	0	if(result != GLOBUS_SUCCESS)
815		{
816	0	xsd_QName               error_qname;
817	0	error_qname.local = prefix;
818	0	error_qname.Namespace = "";
819	0	result = GlobusSoapMessageErrorSerializeFailed(result,
820		NULL,
821		&error_qname);
822	0	goto exit;
823		}
824
825
826		}
827
828	0	if(instance->_Type)
829		{
830
831	0	result = globus_soap_message_attribute_ns_add(
832		message_handle,
833		NULL,
834		&options);
835
836	0	if(result != GLOBUS_SUCCESS)
837		{
838	0	xsd_QName               error_qname;
839	0	error_qname.local = prefix;
840	0	error_qname.Namespace = "";
841	0	result = GlobusSoapMessageErrorSerializeFailed(result,
842		NULL,
843		&error_qname);
844	0	goto exit;
845		}
846
847
848		}
849
850	0	if(instance->_URI)
851		{
852
853	0	result = globus_soap_message_attribute_ns_add(
854		message_handle,
855		NULL,
856		&options);
857
858	0	if(result != GLOBUS_SUCCESS)
859		{
860	0	xsd_QName               error_qname;
861	0	error_qname.local = prefix;
862	0	error_qname.Namespace = "";
863	0	result = GlobusSoapMessageErrorSerializeFailed(result,
864		NULL,
865		&error_qname);
866	0	goto exit;
867		}
868
869
870		}
871
872	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
873		!globus_soap_message_serialize_is_c14n_subset(message_handle))
874		{
875	0	result = globus_soap_message_attribute_ns_add(
876		message_handle,
877		"http://www.w3.org/2001/XMLSchema-instance",
878		&options);
879	0	if(result != GLOBUS_SUCCESS)
880		{
881	0	result = GlobusSoapMessageErrorSerializeFailed(
882		result, NULL, element_qname);
883	0	goto exit;
884		}
885
886	0	result = globus_soap_message_attribute_ns_add(
887		message_handle,
888		ds_ReferenceType_qname.Namespace,
889		&options);
890	0	if(result != GLOBUS_SUCCESS)
891		{
892	0	result = GlobusSoapMessageErrorSerializeFailed(
893		result, NULL, element_qname);
894	0	goto exit;
895		}
896		}
897
898		/* serialize attributes */
899
900	0	subelement.Namespace = "";
901	0	subelement.local = "Id";
902
903	0	if(instance->_Id)
904		{
905
906	0	result = xsd_ID_serialize_attribute(
907		&subelement,
908		instance->_Id,
909		message_handle,
910		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
911	0	if(result != GLOBUS_SUCCESS)
912		{
913	0	result = GlobusSoapMessageErrorSerializeFailed(result,
914		NULL,
915		element_qname);
916	0	goto exit;
917		}
918
919		}
920
921	0	subelement.Namespace = "";
922	0	subelement.local = "Type";
923
924	0	if(instance->_Type)
925		{
926
927	0	result = xsd_anyURI_serialize_attribute(
928		&subelement,
929		instance->_Type,
930		message_handle,
931		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
932	0	if(result != GLOBUS_SUCCESS)
933		{
934	0	result = GlobusSoapMessageErrorSerializeFailed(result,
935		NULL,
936		element_qname);
937	0	goto exit;
938		}
939
940		}
941
942	0	subelement.Namespace = "";
943	0	subelement.local = "URI";
944
945	0	if(instance->_URI)
946		{
947
948	0	result = xsd_anyURI_serialize_attribute(
949		&subelement,
950		instance->_URI,
951		message_handle,
952		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
953	0	if(result != GLOBUS_SUCCESS)
954		{
955	0	result = GlobusSoapMessageErrorSerializeFailed(result,
956		NULL,
957		element_qname);
958	0	goto exit;
959		}
960
961		}
962
963	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
964		!globus_soap_message_serialize_is_c14n_subset(message_handle))
965		{
966	0	result = globus_soap_message_serialize_QName_attribute(
967		message_handle,
968		type_attr,
969		&ds_ReferenceType_qname);
970	0	if(result != GLOBUS_SUCCESS)
971		{
972	0	result = GlobusSoapMessageErrorSerializeFailed(
973		result, NULL, element_qname);
974	0	goto exit;
975		}
976		}
977
978
979	0	result = globus_soap_message_invoke_callouts(
980		message_handle,
981		element_qname,
982		GLOBUS_SOAP_MESSAGE_CALLOUT_ATTR);
983	0	if(result != GLOBUS_SUCCESS)
984		{
985	0	result = GlobusSoapMessageErrorSerializeFailed(
986		result, NULL, element_qname);
987	0	goto exit;
988		}
989		}
990
991	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
992		{
993	0	result = globus_soap_message_serialize_element_begin_close(
994		message_handle);
995	0	if(result != GLOBUS_SUCCESS)
996		{
997	0	result = GlobusSoapMessageErrorSerializeFailed(
998		result, NULL, element_qname);
999	0	goto exit;
1000		}
1001		}
1002	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
1003
1004		/* serialize contents of type */
1005
1006	0	subelement.local = "Transforms";
1007	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1008
1009	0	if(instance->Transforms)
1010		{
1011	0	result = ds_TransformsType_serialize(
1012		&subelement,
1013		instance->Transforms,
1014		message_handle,
1015		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
1016	0	if(result != GLOBUS_SUCCESS)
1017		{
1018	0	result = GlobusSoapMessageErrorSerializeFailed(
1019		result, NULL, &ds_TransformsType_qname);
1020	0	goto exit;
1021		}
1022		}
1023
1024	0	subelement.local = "DigestMethod";
1025	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1026
1027	0	result = ds_DigestMethodType_serialize(
1028		&subelement,
1029		&instance->DigestMethod,
1030		message_handle,
1031		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
1032	0	if(result != GLOBUS_SUCCESS)
1033		{
1034	0	result = GlobusSoapMessageErrorSerializeFailed(
1035		result, NULL, &ds_DigestMethodType_qname);
1036	0	goto exit;
1037		}
1038
1039	0	subelement.local = "DigestValue";
1040	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1041
1042	0	result = ds_DigestValueType_serialize(
1043		&subelement,
1044		&instance->DigestValue,
1045		message_handle,
1046		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
1047	0	if(result != GLOBUS_SUCCESS)
1048		{
1049	0	result = GlobusSoapMessageErrorSerializeFailed(
1050		result, NULL, &ds_DigestValueType_qname);
1051	0	goto exit;
1052		}
1053
1054	0	options = save_options;
1055
1056	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1057		{
1058		/* add end element */
1059	0	result = globus_soap_message_serialize_element_end(
1060		message_handle,
1061		element_qname,
1062		options,
1063		&ds_ReferenceType_qname);
1064	0	if(result != GLOBUS_SUCCESS)
1065		{
1066	0	result = GlobusSoapMessageErrorSerializeFailed(
1067		result, NULL, element_qname);
1068	0	goto exit;
1069		}
1070
1071	0	globus_soap_message_element_ns_remove(
1072		message_handle,
1073		element_qname->Namespace,
1074		&options);
1075
1076		/* remove namespace/prefix mappings for these types */
1077
1078	0	if(instance->_Id)
1079		{
1080
1081	0	globus_soap_message_attribute_ns_remove(
1082		message_handle,
1083		NULL,
1084		&options);
1085
1086		}
1087
1088	0	if(instance->_Type)
1089		{
1090
1091	0	globus_soap_message_attribute_ns_remove(
1092		message_handle,
1093		NULL,
1094		&options);
1095
1096		}
1097
1098	0	if(instance->_URI)
1099		{
1100
1101	0	globus_soap_message_attribute_ns_remove(
1102		message_handle,
1103		NULL,
1104		&options);
1105
1106		}
1107
1108	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
1109		!globus_soap_message_serialize_is_c14n_subset(message_handle))
1110		{
1111	0	globus_soap_message_attribute_ns_remove(
1112		message_handle,
1113		"http://www.w3.org/2001/XMLSchema-instance",
1114		&options);
1115
1116	0	globus_soap_message_attribute_ns_remove(
1117		message_handle,
1118		ds_ReferenceType_qname.Namespace,
1119		&options);
1120		}
1121
1122	0	result = globus_soap_message_invoke_ns_callouts(
1123		message_handle,
1124		element_qname,
1125		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_REMOVE,
1126		&options);
1127	0	if(result != GLOBUS_SUCCESS)
1128		{
1129	0	result  = GlobusSoapMessageErrorSerializeFailed(
1130		result, NULL, element_qname);
1131	0	goto exit;
1132		}
1133
1134	0	result = globus_soap_message_invoke_callouts(
1135		message_handle,
1136		element_qname,
1137		GLOBUS_SOAP_MESSAGE_CALLOUT_END);
1138	0	if(result != GLOBUS_SUCCESS)
1139		{
1140	0	result = GlobusSoapMessageErrorSerializeFailed(
1141		result, NULL, element_qname);
1142		goto exit;
1143		}
1144		}
1145
1146		exit:
1147	0	if (type_attr)
1148		{
1149	0	xsd_QName_destroy(type_attr);
1150		}
1151
1152	0	if(any_attr_keys)
1153		{
1154	0	globus_list_free(any_attr_keys);
1155		}
1156
1157	0	GlobusSoapMessageDebugExit();
1158	0	return result;
1159		}
1160
1161
1162
1163		globus_result_t
1164		ds_ReferenceType_deserialize_contents(
1165		xsd_QName *                         element_qname, /* ignored */
1166		ds_ReferenceType * inst,
1167		globus_soap_message_handle_t        message_handle,
1168		globus_xsd_element_options_t        options)
1169	0	{
1170	0	globus_result_t                     result = GLOBUS_SUCCESS;
1171	0	GlobusFuncName(ds_ReferenceType_deserialize_contents);
1172	0	GlobusSoapMessageDebugEnter();
1173
1174	0	result = ds_ReferenceType_deserialize(
1175		NULL,
1176		inst,
1177		message_handle,
1178		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1179	0	if(result != GLOBUS_SUCCESS)
1180		{
1181	0	result = GlobusSoapMessageErrorDeserializeFailed(
1182		result, element_qname);
1183		goto exit;
1184		}
1185
1186		exit:
1187
1188	0	GlobusSoapMessageDebugExit();
1189	0	return result;
1190		}
1191
1192
1193
1194		globus_result_t
1195		ds_ReferenceType_deserialize(
1196		xsd_QName *                         element_qname,
1197		ds_ReferenceType * instance,
1198		globus_soap_message_handle_t        message_handle,
1199		globus_xsd_element_options_t        options)
1200	0	{
1201	0	globus_result_t                     result = GLOBUS_SUCCESS;
1202	0	xsd_QName                           subelement;
1203	0	GlobusFuncName(ds_ReferenceType_deserialize);
1204	0	GlobusSoapMessageDebugEnter();
1205
1206
1207	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1208		{
1209	0	result = globus_soap_message_deserialize_element(
1210		message_handle, element_qname);
1211	0	if(result != GLOBUS_SUCCESS)
1212		{
1213	0	result = GlobusSoapMessageErrorDeserializeFailed(
1214		result, element_qname);
1215	0	goto exit;
1216		}
1217
1218	0	subelement.Namespace = "";
1219	0	subelement.local = "Id";
1220
1221	0	result = xsd_ID_deserialize_attribute_pointer(
1222		&subelement,
1223		&instance->_Id,
1224		message_handle,
1225		0);
1226	0	if(result != GLOBUS_SUCCESS)
1227		{
1228	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1229	0	goto _Id_destroy;
1230		}
1231
1232
1233	0	subelement.Namespace = "";
1234	0	subelement.local = "Type";
1235
1236	0	result = xsd_anyURI_deserialize_attribute_pointer(
1237		&subelement,
1238		&instance->_Type,
1239		message_handle,
1240		0);
1241	0	if(result != GLOBUS_SUCCESS)
1242		{
1243	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1244	0	goto _Type_destroy;
1245		}
1246
1247
1248	0	subelement.Namespace = "";
1249	0	subelement.local = "URI";
1250
1251	0	result = xsd_anyURI_deserialize_attribute_pointer(
1252		&subelement,
1253		&instance->_URI,
1254		message_handle,
1255		0);
1256	0	if(result != GLOBUS_SUCCESS)
1257		{
1258	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1259	0	goto _URI_destroy;
1260		}
1261
1262
1263
1264	0	result = globus_soap_message_deserialize_element_begin_close(
1265		message_handle);
1266	0	if(result != GLOBUS_SUCCESS)
1267		{
1268	0	result = GlobusSoapMessageErrorDeserializeFailed(
1269		result, element_qname);
1270	0	goto fail_deserialize;
1271		}
1272		}
1273
1274	0	subelement.local = "Transforms";
1275	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1276
1277	0	result = ds_TransformsType_deserialize_pointer(
1278		&subelement,
1279		&instance->Transforms,
1280		message_handle,
1281		0);
1282	0	if(result != GLOBUS_SUCCESS)
1283		{
1284	0	result = GlobusSoapMessageErrorDeserializeFailed(
1285		result,
1286		(&subelement));
1287	0	goto Transforms_destroy_pointer;
1288		}
1289
1290	0	subelement.local = "DigestMethod";
1291	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1292
1293	0	result = ds_DigestMethodType_deserialize(
1294		&subelement,
1295		&instance->DigestMethod,
1296		message_handle,
1297		0);
1298	0	if(result != GLOBUS_SUCCESS)
1299		{
1300	0	result = GlobusSoapMessageErrorDeserializeFailed(
1301		result,
1302		&ds_DigestMethodType_qname);
1303	0	goto DigestMethod_destroy;
1304		}
1305
1306	0	subelement.local = "DigestValue";
1307	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1308
1309	0	result = ds_DigestValueType_deserialize(
1310		&subelement,
1311		&instance->DigestValue,
1312		message_handle,
1313		0);
1314	0	if(result != GLOBUS_SUCCESS)
1315		{
1316	0	result = GlobusSoapMessageErrorDeserializeFailed(
1317		result,
1318		&ds_DigestValueType_qname);
1319	0	goto DigestValue_destroy;
1320		}
1321
1322	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1323		{
1324	0	result = globus_soap_message_deserialize_element_end(
1325		message_handle,
1326		element_qname);
1327	0	if(result != GLOBUS_SUCCESS)
1328		{
1329	0	result = GlobusSoapMessageErrorDeserializeFailed(
1330		result, element_qname);
1331		goto fail_deserialize;
1332		}
1333		}
1334
1335	0	goto exit;
1336
1337		fail_deserialize:
1338
1339		_Id_destroy:
1340
1341	0	if(instance->_Id)
1342		{
1343	0	xsd_ID_destroy(
1344		instance->_Id);
1345	0	instance->_Id = NULL;
1346		}
1347
1348		_Type_destroy:
1349
1350	0	if(instance->_Type)
1351		{
1352	0	xsd_anyURI_destroy(
1353		instance->_Type);
1354	0	instance->_Type = NULL;
1355		}
1356
1357		_URI_destroy:
1358
1359	0	if(instance->_URI)
1360		{
1361	0	xsd_anyURI_destroy(
1362		instance->_URI);
1363	0	instance->_URI = NULL;
1364		}
1365	0	ds_DigestValueType_destroy_contents(
1366		&instance->DigestValue);
1367
1368		DigestValue_destroy:
1369	0	ds_DigestMethodType_destroy_contents(
1370		&instance->DigestMethod);
1371
1372		DigestMethod_destroy:
1373	0	ds_TransformsType_destroy(
1374		instance->Transforms);
1375	0	instance->Transforms = NULL;
1376
1377		Transforms_destroy_pointer:
1378
1379
1380		exit:
1381
1382	0	GlobusSoapMessageDebugExit();
1383	0	return result;
1384		}
1385
1386
1387
1388		globus_result_t
1389		ds_ReferenceType_deserialize_pointer(
1390		xsd_QName *                         element_qname,
1391		ds_ReferenceType ** ip,
1392		globus_soap_message_handle_t        message_handle,
1393		globus_xsd_element_options_t        options)
1394	0	{
1395	0	ds_ReferenceType * instance = NULL;
1396	0	globus_result_t                     result = GLOBUS_SUCCESS;
1397	0	xsd_QName                           subelement;
1398	0	int                                 found_attrs = 0;
1399	0	int                                 empty_element = 0;
1400	0	GlobusFuncName(ds_ReferenceType_deserialize_pointer);
1401	0	GlobusSoapMessageDebugEnter();
1402
1403	0	*ip = NULL;
1404
1405	0	result = globus_soap_message_deserialize_element(
1406		message_handle, element_qname);
1407	0	if(result != GLOBUS_SUCCESS &&
1408		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1409		GlobusSoapMessageStatusFailedElementCheck(result) ||
1410		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1411		{
1412	0	*ip = NULL;
1413	0	result = GLOBUS_SUCCESS;
1414	0	goto exit;
1415		}
1416
1417	0	if(result != GLOBUS_SUCCESS)
1418		{
1419	0	result = GlobusSoapMessageErrorDeserializeFailed(
1420		result, element_qname);
1421	0	goto exit;
1422		}
1423
1424	0	if(globus_soap_message_deserialize_element_is_empty(
1425		message_handle))
1426		{
1427	0	empty_element = 1;
1428		}
1429
1430
1431
1432	0	result = ds_ReferenceType_init(&instance);
1433	0	if(result != GLOBUS_SUCCESS)
1434		{
1435	0	result = GlobusSoapMessageErrorDeserializeFailed(
1436		result, element_qname);
1437	0	goto exit;
1438		}
1439
1440
1441	0	subelement.Namespace = "";
1442	0	subelement.local = "Id";
1443
1444	0	result = xsd_ID_deserialize_attribute_pointer(
1445		&subelement,
1446		&instance->_Id,
1447		message_handle,
1448		0);
1449	0	if(result != GLOBUS_SUCCESS)
1450		{
1451	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1452	0	goto _Id_destroy;
1453		}
1454
1455
1456	0	if(instance->_Id)
1457		{
1458	0	found_attrs++;
1459		}
1460
1461	0	subelement.Namespace = "";
1462	0	subelement.local = "Type";
1463
1464	0	result = xsd_anyURI_deserialize_attribute_pointer(
1465		&subelement,
1466		&instance->_Type,
1467		message_handle,
1468		0);
1469	0	if(result != GLOBUS_SUCCESS)
1470		{
1471	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1472	0	goto _Type_destroy;
1473		}
1474
1475
1476	0	if(instance->_Type)
1477		{
1478	0	found_attrs++;
1479		}
1480
1481	0	subelement.Namespace = "";
1482	0	subelement.local = "URI";
1483
1484	0	result = xsd_anyURI_deserialize_attribute_pointer(
1485		&subelement,
1486		&instance->_URI,
1487		message_handle,
1488		0);
1489	0	if(result != GLOBUS_SUCCESS)
1490		{
1491	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1492	0	goto _URI_destroy;
1493		}
1494
1495
1496	0	if(instance->_URI)
1497		{
1498	0	found_attrs++;
1499		}
1500
1501	0	if(found_attrs == 0 &&
1502		globus_soap_message_deserialize_element_is_nil(message_handle))
1503		{
1504	0	ds_ReferenceType_destroy(instance);
1505
1506	0	result = globus_soap_message_deserialize_element_end(
1507		message_handle,
1508		element_qname);
1509	0	if(result != GLOBUS_SUCCESS)
1510		{
1511	0	result = GlobusSoapMessageErrorDeserializeFailed(
1512		result, element_qname);
1513	0	goto exit;
1514		}
1515
1516	0	*ip = NULL;
1517	0	globus_object_free(globus_error_get(result));
1518	0	result = GLOBUS_SUCCESS;
1519	0	goto exit;
1520		}
1521
1522
1523	0	if(empty_element)
1524		{
1525	0	result = globus_soap_message_deserialize_element_end(
1526		message_handle,
1527		element_qname);
1528	0	if(result != GLOBUS_SUCCESS)
1529		{
1530	0	result = GlobusSoapMessageErrorDeserializeFailed(
1531		result, element_qname);
1532	0	goto fail_deserialize;
1533		}
1534
1535	0	*ip = instance;
1536	0	goto exit;
1537		}
1538
1539	0	result = globus_soap_message_deserialize_element_begin_close(
1540		message_handle);
1541	0	if(result != GLOBUS_SUCCESS)
1542		{
1543	0	result = GlobusSoapMessageErrorDeserializeFailed(
1544		result, element_qname);
1545	0	goto exit;
1546		}
1547
1548
1549	0	subelement.local = "Transforms";
1550	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1551
1552	0	result = ds_TransformsType_deserialize_pointer(
1553		&subelement,
1554		&instance->Transforms,
1555		message_handle,
1556		0);
1557	0	if(result != GLOBUS_SUCCESS)
1558		{
1559	0	result = GlobusSoapMessageErrorDeserializeFailed(
1560		result,
1561		(&subelement));
1562	0	goto Transforms_destroy_pointer;
1563		}
1564
1565	0	subelement.local = "DigestMethod";
1566	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1567
1568	0	result = ds_DigestMethodType_deserialize(
1569		&subelement,
1570		&instance->DigestMethod,
1571		message_handle,
1572		0);
1573	0	if(result != GLOBUS_SUCCESS)
1574		{
1575	0	result = GlobusSoapMessageErrorDeserializeFailed(
1576		result,
1577		&ds_DigestMethodType_qname);
1578	0	goto DigestMethod_destroy;
1579		}
1580
1581	0	subelement.local = "DigestValue";
1582	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1583
1584	0	result = ds_DigestValueType_deserialize(
1585		&subelement,
1586		&instance->DigestValue,
1587		message_handle,
1588		0);
1589	0	if(result != GLOBUS_SUCCESS)
1590		{
1591	0	result = GlobusSoapMessageErrorDeserializeFailed(
1592		result,
1593		&ds_DigestValueType_qname);
1594	0	goto DigestValue_destroy;
1595		}
1596
1597
1598	0	result = globus_soap_message_deserialize_element_end(
1599		message_handle,
1600		element_qname);
1601	0	if(result != GLOBUS_SUCCESS)
1602		{
1603	0	result = GlobusSoapMessageErrorDeserializeFailed(
1604		result, element_qname);
1605	0	goto fail_deserialize;
1606		}
1607
1608	0	*ip = instance;
1609
1610	0	goto exit;
1611
1612		fail_deserialize:
1613
1614		_Id_destroy:
1615
1616	0	if(instance->_Id)
1617		{
1618	0	xsd_ID_destroy(
1619		instance->_Id);
1620	0	instance->_Id = NULL;
1621		}
1622
1623		_Type_destroy:
1624
1625	0	if(instance->_Type)
1626		{
1627	0	xsd_anyURI_destroy(
1628		instance->_Type);
1629	0	instance->_Type = NULL;
1630		}
1631
1632		_URI_destroy:
1633
1634	0	if(instance->_URI)
1635		{
1636	0	xsd_anyURI_destroy(
1637		instance->_URI);
1638	0	instance->_URI = NULL;
1639		}
1640	0	ds_DigestValueType_destroy_contents(
1641		&instance->DigestValue);
1642
1643		DigestValue_destroy:
1644	0	ds_DigestMethodType_destroy_contents(
1645		&instance->DigestMethod);
1646
1647		DigestMethod_destroy:
1648	0	ds_TransformsType_destroy(
1649		instance->Transforms);
1650	0	instance->Transforms = NULL;
1651
1652		Transforms_destroy_pointer:
1653
1654		exit:
1655
1656	0	GlobusSoapMessageDebugExit();
1657	0	return result;
1658		}
1659
1660
1661		globus_result_t
1662		ds_ReferenceType_array_init_contents(
1663		ds_ReferenceType_array * array)
1664	0	{
1665	0	GlobusFuncName(ds_ReferenceType_array_init_contents);
1666	0	GlobusSoapMessageDebugEnter();
1667
1668	0	memset(array, 0, sizeof(ds_ReferenceType_array));
1669
1670	0	GlobusSoapMessageDebugExit();
1671	0	return GLOBUS_SUCCESS;
1672		}
1673
1674		globus_result_t
1675		ds_ReferenceType_array_init(
1676		ds_ReferenceType_array ** arr)
1677	0	{
1678	0	ds_ReferenceType_array * array;
1679	0	globus_result_t                     result;
1680	0	GlobusFuncName(ds_ReferenceType_array_init);
1681	0	GlobusSoapMessageDebugEnter();
1682
1683	0	array = (ds_ReferenceType_array *)
1684		globus_malloc(sizeof(ds_ReferenceType_array));
1685	0	if(!array)
1686		{
1687	0	result = GlobusSoapMessageErrorOutOfMemory;
1688	0	goto exit;
1689		}
1690
1691	0	result = ds_ReferenceType_array_init_contents(array);
1692	0	if(result != GLOBUS_SUCCESS)
1693		{
1694	0	globus_free(array);
1695	0	array = NULL;
1696
1697		}
1698
1699	0	*arr = array;
1700
1701		exit:
1702	0	GlobusSoapMessageDebugExit();
1703	0	return result;
1704		}
1705
1706		void
1707		ds_ReferenceType_array_destroy_contents(
1708		ds_ReferenceType_array * array)
1709	0	{
1710	0	int                                 i = 0;
1711	0	GlobusFuncName(ds_ReferenceType_array_destroy_contents);
1712	0	GlobusSoapMessageDebugEnter();
1713
1714	0	for(; i < array->length; ++i)
1715		{
1716	0	ds_ReferenceType_destroy_contents(&array->elements[i]);
1717		}
1718
1719	0	if(array->elements)
1720		{
1721	0	globus_free(array->elements);
1722	0	array->elements = NULL;
1723		}
1724	0	array->length = 0;
1725
1726	0	GlobusSoapMessageDebugExit();
1727		}
1728
1729		void
1730		ds_ReferenceType_array_destroy(
1731		ds_ReferenceType_array * array)
1732	0	{
1733	0	GlobusFuncName(ds_ReferenceType_array_destroy);
1734	0	GlobusSoapMessageDebugEnter();
1735
1736	0	ds_ReferenceType_array_destroy_contents(array);
1737	0	globus_free(array);
1738
1739	0	GlobusSoapMessageDebugExit();
1740		}
1741
1742		globus_result_t
1743		ds_ReferenceType_array_copy(
1744		ds_ReferenceType_array ** dest_arr,
1745		const ds_ReferenceType_array * src_arr)
1746	0	{
1747	0	ds_ReferenceType_array * array;
1748	0	globus_result_t                     result;
1749	0	GlobusFuncName(ds_ReferenceType_array_copy);
1750	0	GlobusSoapMessageDebugEnter();
1751
1752	0	array = (ds_ReferenceType_array *) globus_malloc(
1753		sizeof(ds_ReferenceType_array));
1754	0	if(!array)
1755		{
1756	0	result = GlobusSoapMessageErrorOutOfMemory;
1757	0	GlobusSoapMessageDebugExit();
1758	0	return result;
1759		}
1760
1761	0	result = ds_ReferenceType_array_copy_contents(array, src_arr);
1762	0	if(result != GLOBUS_SUCCESS)
1763		{
1764	0	globus_free(array);
1765	0	GlobusSoapMessageDebugExit();
1766	0	return result;
1767		}
1768
1769	0	*dest_arr = array;
1770
1771	0	GlobusSoapMessageDebugExit();
1772	0	return GLOBUS_SUCCESS;
1773		}
1774
1775		globus_result_t
1776		ds_ReferenceType_array_copy_contents(
1777		ds_ReferenceType_array * dest_arr,
1778		const ds_ReferenceType_array * src_arr)
1779	0	{
1780	0	int                                 i;
1781	0	globus_result_t                     result = GLOBUS_SUCCESS;
1782	0	GlobusFuncName(ds_ReferenceType_array_copy_contents);
1783	0	GlobusSoapMessageDebugEnter();
1784
1785	0	dest_arr->length = src_arr->length;
1786	0	if(dest_arr->length > 0)
1787		{
1788	0	dest_arr->elements = (ds_ReferenceType *) malloc(
1789		sizeof(ds_ReferenceType) * dest_arr->length);
1790	0	if(!dest_arr->elements)
1791		{
1792	0	result = GlobusSoapMessageErrorOutOfMemory;
1793	0	GlobusSoapMessageDebugExit();
1794	0	return result;
1795		}
1796		}
1797		else
1798		{
1799	0	dest_arr->elements = NULL;
1800		}
1801
1802	0	for(i = 0; i < dest_arr->length; i++)
1803		{
1804	0	result = ds_ReferenceType_copy_contents(
1805		&dest_arr->elements[i], &src_arr->elements[i]);
1806	0	if(result != GLOBUS_SUCCESS)
1807		{
1808	0	while(i--)
1809		{
1810	0	ds_ReferenceType_destroy_contents(&dest_arr->elements[i]);
1811		}
1812
1813	0	globus_free(dest_arr->elements);
1814	0	dest_arr->elements = NULL;
1815	0	dest_arr->length = 0;
1816	0	break;
1817		}
1818		}
1819
1820	0	GlobusSoapMessageDebugExit();
1821	0	return result;
1822		}
1823
1824		ds_ReferenceType *
1825		ds_ReferenceType_array_push(
1826		ds_ReferenceType_array * array)
1827	0	{
1828	0	GlobusFuncName(ds_ReferenceType_array_push);
1829	0	GlobusSoapMessageDebugEnter();
1830
1831	0	array->elements = realloc(array->elements,
1832		sizeof(ds_ReferenceType) *
1833		(array->length + 1));
1834	0	memset(&array->elements[array->length], 0, sizeof(ds_ReferenceType));
1835	0	array->length++;
1836
1837	0	GlobusSoapMessageDebugExit();
1838	0	return (&array->elements[array->length - 1]);
1839		}
1840
1841		void *
1842		ds_ReferenceType_array_push_wrapper(
1843		void * array)
1844	0	{
1845	0	return (void *) ds_ReferenceType_array_push((ds_ReferenceType_array *) array);
1846		}
1847
1848		globus_result_t
1849		ds_ReferenceType_array_serialize(
1850		xsd_QName *                         element_qname,
1851		ds_ReferenceType_array * array,
1852		globus_soap_message_handle_t        message,
1853		globus_xsd_element_options_t        options)
1854	0	{
1855	0	globus_result_t                     result = GLOBUS_SUCCESS;
1856	0	int                                 i = 0;
1857	0	GlobusFuncName(ds_ReferenceType_array_serialize);
1858	0	GlobusSoapMessageDebugEnter();
1859
1860	0	for(; i < array->length; ++i)
1861		{
1862	0	result = ds_ReferenceType_serialize(
1863		element_qname,
1864		&array->elements[i],
1865		message,
1866		options);
1867	0	if(result != GLOBUS_SUCCESS)
1868		{
1869	0	goto exit;
1870		}
1871		}
1872
1873		exit:
1874
1875	0	GlobusSoapMessageDebugExit();
1876	0	return result;
1877		}
1878
1879		globus_result_t
1880		ds_ReferenceType_array_deserialize(
1881		xsd_QName *                         element_qname,
1882		ds_ReferenceType_array * array,
1883		globus_soap_message_handle_t        message,
1884		globus_xsd_element_options_t        options)
1885	0	{
1886	0	globus_result_t                     result = GLOBUS_SUCCESS;
1887	0	int                                 i = 0;
1888	0	int                                 pre_length;
1889	0	GlobusFuncName(ds_ReferenceType_array_deserialize);
1890	0	GlobusSoapMessageDebugEnter();
1891
1892	0	pre_length = array->length;
1893
1894	0	for(i = 0; i < pre_length; ++i)
1895		{
1896	0	result = ds_ReferenceType_deserialize(
1897		element_qname,
1898		&array->elements[i],
1899		message,
1900		options);
1901	0	if(result != GLOBUS_SUCCESS)
1902		{
1903	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1904		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1905		GlobusSoapMessageStatusFailedWithTextCheck(result))
1906		{
1907	0	result = GLOBUS_SUCCESS;
1908	0	break;
1909		}
1910
1911	0	result = GlobusSoapMessageErrorDeserializeFailed(
1912		result, element_qname);
1913	0	goto exit;
1914		}
1915		}
1916
1917	0	while(result == GLOBUS_SUCCESS)
1918		{
1919	0	ds_ReferenceType                  next;
1920	0	memset(&next, 0, sizeof(ds_ReferenceType));
1921
1922	0	result = ds_ReferenceType_deserialize(
1923		element_qname,
1924		&next,
1925		message,
1926		options);
1927	0	if(result != GLOBUS_SUCCESS)
1928		{
1929	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1930		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1931		GlobusSoapMessageStatusFailedWithTextCheck(result))
1932		{
1933	0	result = GLOBUS_SUCCESS;
1934	0	break;
1935		}
1936
1937	0	result = GlobusSoapMessageErrorDeserializeFailed(
1938		result, element_qname);
1939	0	goto exit;
1940		}
1941
1942	0	array->elements = realloc(
1943		array->elements,
1944		(array->length + 1) * sizeof(ds_ReferenceType));
1945	0	if(!array->elements)
1946		{
1947	0	result = GlobusSoapMessageErrorOutOfMemory;
1948	0	goto exit;
1949		}
1950	0	array->elements[array->length] = next;
1951	0	array->length++;
1952	0	++i;
1953		}
1954
1955		exit:
1956
1957	0	if(result != GLOBUS_SUCCESS)
1958		{
1959	0	int                             di = 0;
1960	0	for(; di < i; ++di)
1961		{
1962	0	ds_ReferenceType_destroy_contents(
1963		&array->elements[di]);
1964	0	memset(&array->elements[di], 0, sizeof(ds_ReferenceType));
1965		}
1966		}
1967
1968	0	GlobusSoapMessageDebugExit();
1969	0	return result;