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_SignaturePropertyType.h"
21
22		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
23		xsd_QName ds_SignaturePropertyType_qname =
24		{
25		DS_SIGNATUREPROPERTYTYPE_NS,
26		DS_SIGNATUREPROPERTYTYPE_LOCAL
27		};
28		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
29
30		globus_result_t
31		ds_SignaturePropertyType_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_SignaturePropertyType_serialize(
38		element_qname,
39		(ds_SignaturePropertyType *) instance,
40		message_handle, options);
41		}
42
43		globus_result_t
44		ds_SignaturePropertyType_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_SignaturePropertyType_deserialize_pointer(
51		element_qname,
52		(ds_SignaturePropertyType **) ip,
53		message_handle, options);
54		}
55
56		globus_result_t
57		ds_SignaturePropertyType_init_wrapper(void **object)
58	0	{
59	0	return ds_SignaturePropertyType_init(
60		(ds_SignaturePropertyType **) object);
61		}
62
63		void
64		ds_SignaturePropertyType_destroy_wrapper(
65		void *                          object)
66	0	{
67	0	ds_SignaturePropertyType_destroy(
68		(ds_SignaturePropertyType *) object);
69		}
70
71		globus_result_t
72		ds_SignaturePropertyType_copy_wrapper(
73		void **                         dest_obj,
74		void *                          src_obj)
75	0	{
76	0	return ds_SignaturePropertyType_copy(
77		(ds_SignaturePropertyType **) dest_obj,
78		(ds_SignaturePropertyType *) src_obj);
79		}
80
81		globus_result_t
82		ds_SignaturePropertyType_init_contents_wrapper(void *object)
83	0	{
84	0	return ds_SignaturePropertyType_init_contents(
85		(ds_SignaturePropertyType *) object);
86		}
87
88		void
89		ds_SignaturePropertyType_destroy_contents_wrapper(
90		void *                          object)
91	0	{
92	0	ds_SignaturePropertyType_destroy_contents(
93		(ds_SignaturePropertyType *) object);
94		}
95
96		globus_result_t
97		ds_SignaturePropertyType_copy_contents_wrapper(
98		void *                          dest_obj,
99		void *                          src_obj)
100	0	{
101	0	return ds_SignaturePropertyType_copy_contents(
102		(ds_SignaturePropertyType *) dest_obj,
103		(ds_SignaturePropertyType *) src_obj);
104		}
105
106		globus_result_t
107		ds_SignaturePropertyType_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_SignaturePropertyType_serialize_contents(
114		element_qname,
115		(ds_SignaturePropertyType *) instance,
116		message_handle, options);
117		}
118
119		globus_result_t
120		ds_SignaturePropertyType_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_SignaturePropertyType_deserialize_contents_wrapper);
128	0	GlobusSoapMessageDebugEnter();
129
130	0	if(!*instance)
131		{
132	0	result = ds_SignaturePropertyType_init(
133		(ds_SignaturePropertyType **)instance);
134	0	if(result != GLOBUS_SUCCESS)
135		{
136	0	goto error;
137		}
138		}
139
140	0	result = ds_SignaturePropertyType_deserialize_contents(
141		element_qname,
142		*(ds_SignaturePropertyType **)instance,
143		message_handle, options);
144		error:
145	0	GlobusSoapMessageDebugExit();
146	0	return result;
147		}
148
149		globus_result_t
150		ds_SignaturePropertyType_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_SignaturePropertyType_array_serialize(
157		element,
158		(ds_SignaturePropertyType_array *) instance,
159		message, options);
160		}
161
162		globus_result_t
163		ds_SignaturePropertyType_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_SignaturePropertyType_array_init(
174		(ds_SignaturePropertyType_array **)inst);
175	0	if(result != GLOBUS_SUCCESS)
176		{
177	0	return result;
178		}
179		}
180
181	0	return ds_SignaturePropertyType_array_deserialize(
182		element_qname,
183		*(ds_SignaturePropertyType_array **) inst,
184		message, options);
185		}
186
187		globus_result_t
188		ds_SignaturePropertyType_array_init_wrapper(
189		void **                             arr)
190	0	{
191	0	return ds_SignaturePropertyType_array_init(
192		(ds_SignaturePropertyType_array **) arr);
193		}
194
195		void
196		ds_SignaturePropertyType_array_destroy_wrapper(
197		void *                              arr)
198	0	{
199	0	ds_SignaturePropertyType_array_destroy(
200		(ds_SignaturePropertyType_array *) arr);
201		}
202
203		globus_result_t
204		ds_SignaturePropertyType_array_copy_wrapper(
205		void **                             dest_arr,
206		void *                              src_arr)
207	0	{
208	0	return ds_SignaturePropertyType_array_copy(
209		(ds_SignaturePropertyType_array **) dest_arr,
210		(ds_SignaturePropertyType_array *) src_arr);
211		}
212
213		globus_result_t
214		ds_SignaturePropertyType_array_init_contents_wrapper(
215		void *                              arr)
216	0	{
217	0	return ds_SignaturePropertyType_array_init_contents(
218		(ds_SignaturePropertyType_array *) arr);
219		}
220
221		void
222		ds_SignaturePropertyType_array_destroy_contents_wrapper(
223		void *                              arr)
224	0	{
225	0	ds_SignaturePropertyType_array_destroy_contents(
226		(ds_SignaturePropertyType_array *) arr);
227		}
228
229		globus_result_t
230		ds_SignaturePropertyType_array_copy_contents_wrapper(
231		void *                              dest_arr,
232		void *                              src_arr)
233	0	{
234	0	return ds_SignaturePropertyType_array_copy_contents(
235		(ds_SignaturePropertyType_array *) dest_arr,
236		(ds_SignaturePropertyType_array *) src_arr);
237		}
238
239		struct globus_xsd_type_info_s ds_SignaturePropertyType_contents_info =
240		{
241		&ds_SignaturePropertyType_qname,
242		ds_SignaturePropertyType_serialize_contents_wrapper,
243		ds_SignaturePropertyType_deserialize_contents_wrapper,
244		ds_SignaturePropertyType_init_wrapper,
245		ds_SignaturePropertyType_destroy_wrapper,
246		ds_SignaturePropertyType_copy_wrapper,
247		ds_SignaturePropertyType_init_contents_wrapper,
248		ds_SignaturePropertyType_destroy_contents_wrapper,
249		ds_SignaturePropertyType_copy_contents_wrapper,
250		sizeof(ds_SignaturePropertyType),
251		NULL,
252		NULL,
253		NULL
254		};
255
256		struct globus_xsd_type_info_s ds_SignaturePropertyType_array_info =
257		{
258		&ds_SignaturePropertyType_qname,
259		ds_SignaturePropertyType_array_serialize_wrapper,
260		ds_SignaturePropertyType_array_deserialize_wrapper,
261		ds_SignaturePropertyType_array_init_wrapper,
262		ds_SignaturePropertyType_array_destroy_wrapper,
263		ds_SignaturePropertyType_array_copy_wrapper,
264		ds_SignaturePropertyType_array_init_contents_wrapper,
265		ds_SignaturePropertyType_array_destroy_contents_wrapper,
266		ds_SignaturePropertyType_array_copy_contents_wrapper,
267		sizeof(ds_SignaturePropertyType),
268		ds_SignaturePropertyType_array_push_wrapper,
269		NULL,
270		NULL
271		};
272
273		struct globus_xsd_type_info_s ds_SignaturePropertyType_info =
274		{
275		&ds_SignaturePropertyType_qname,
276		ds_SignaturePropertyType_serialize_wrapper,
277		ds_SignaturePropertyType_deserialize_pointer_wrapper,
278		ds_SignaturePropertyType_init_wrapper,
279		ds_SignaturePropertyType_destroy_wrapper,
280		ds_SignaturePropertyType_copy_wrapper,
281		ds_SignaturePropertyType_init_contents_wrapper,
282		ds_SignaturePropertyType_destroy_contents_wrapper,
283		ds_SignaturePropertyType_copy_contents_wrapper,
284		sizeof(ds_SignaturePropertyType),
285		NULL,
286		&ds_SignaturePropertyType_contents_info,
287		&ds_SignaturePropertyType_array_info
288		};
289
290		globus_result_t
291		ds_SignaturePropertyType_init_contents(
292		ds_SignaturePropertyType * instance)
293	0	{
294	0	globus_result_t                     result = GLOBUS_SUCCESS;
295	0	GlobusFuncName(ds_SignaturePropertyType_init_contents);
296	0	GlobusSoapMessageDebugEnter();
297
298	0	memset(instance, 0, sizeof(ds_SignaturePropertyType));
299
300	0	GlobusSoapMessageDebugExit();
301	0	return result;
302		}
303
304		globus_result_t
305		ds_SignaturePropertyType_init(
306		ds_SignaturePropertyType ** object)
307	0	{
308	0	ds_SignaturePropertyType * instance;
309	0	globus_result_t                     result = GLOBUS_SUCCESS;
310	0	GlobusFuncName(ds_SignaturePropertyType_init);
311	0	GlobusSoapMessageDebugEnter();
312
313	0	instance = globus_malloc(sizeof(ds_SignaturePropertyType));
314	0	if(!instance)
315		{
316	0	result = GlobusSoapMessageErrorOutOfMemory;
317	0	goto exit;
318		}
319
320	0	memset(instance, 0, sizeof(ds_SignaturePropertyType));
321
322	0	*object = instance;
323
324		exit:
325	0	GlobusSoapMessageDebugExit();
326	0	return result;
327		}
328
329		void
330		ds_SignaturePropertyType_destroy(
331		ds_SignaturePropertyType * instance)
332	0	{
333	0	GlobusFuncName(ds_SignaturePropertyType_destroy);
334	0	GlobusSoapMessageDebugEnter();
335
336	0	if(!instance)
337		{
338	0	goto exit;
339		}
340
341	0	ds_SignaturePropertyType_destroy_contents(instance);
342	0	globus_free(instance);
343
344		exit:
345
346	0	GlobusSoapMessageDebugExit();
347		}
348
349		void
350		ds_SignaturePropertyType_destroy_contents(
351		ds_SignaturePropertyType * instance)
352	0	{
353	0	GlobusFuncName(ds_SignaturePropertyType_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	if(instance)
357		{
358
359
360	0	ds_SignaturePropertyType_choice_array_destroy_contents(&instance->choice_value);
361
362	0	if(instance->_Id)
363		{
364	0	xsd_ID_destroy(
365		instance->_Id);
366	0	instance->_Id = NULL;
367		}
368
369	0	xsd_anyURI_destroy_contents(
370		&instance->_Target);
371
372		}
373
374	0	GlobusSoapMessageDebugExit();
375		}
376
377		globus_result_t
378		ds_SignaturePropertyType_copy(
379		ds_SignaturePropertyType ** dest_obj,
380		const ds_SignaturePropertyType * src_obj)
381	0	{
382	0	globus_result_t                     result = GLOBUS_SUCCESS;
383	0	ds_SignaturePropertyType * instance;
384	0	GlobusFuncName(ds_SignaturePropertyType_copy);
385
386	0	GlobusSoapMessageDebugEnter();
387
388	0	instance = malloc(sizeof(ds_SignaturePropertyType));
389	0	if (instance == NULL)
390		{
391	0	GlobusSoapMessageDebugExit();
392	0	return GlobusSoapMessageErrorOutOfMemory;
393		}
394
395	0	result = ds_SignaturePropertyType_copy_contents(instance, src_obj);
396	0	if(result != GLOBUS_SUCCESS)
397		{
398	0	globus_free(instance);
399	0	GlobusSoapMessageDebugExit();
400	0	return GlobusSoapMessageErrorOutOfMemory;
401		}
402
403	0	*dest_obj = instance;
404	0	GlobusSoapMessageDebugExit();
405	0	return result;
406		}
407
408		globus_result_t
409		ds_SignaturePropertyType_copy_contents(
410		ds_SignaturePropertyType * instance,
411		const ds_SignaturePropertyType * src_obj)
412	0	{
413	0	globus_result_t                     result = GLOBUS_SUCCESS;
414	0	GlobusFuncName(ds_SignaturePropertyType_copy_contents);
415
416	0	GlobusSoapMessageDebugEnter();
417
418
419	0	if(src_obj->_Id)
420		{
421	0	result = xsd_ID_copy(
422		&instance->_Id,
423		src_obj->_Id);
424	0	if(result != GLOBUS_SUCCESS)
425		{
426	0	result = GlobusSoapMessageErrorCopyFailed(
427		result, NULL, &xsd_ID_qname);
428	0	goto _Id_destroy;
429		}
430		}
431		else
432		{
433	0	instance->_Id = NULL;
434		}
435
436	0	result = xsd_anyURI_copy_contents(
437		&instance->_Target,
438		&src_obj->_Target);
439	0	if(result != GLOBUS_SUCCESS)
440		{
441	0	result = GlobusSoapMessageErrorCopyFailed(
442		result, NULL, &xsd_anyURI_qname);
443	0	goto _Target_destroy;
444		}
445
446	0	result = ds_SignaturePropertyType_choice_array_copy_contents(
447		&instance->choice_value,
448		&src_obj->choice_value);
449	0	if(result != GLOBUS_SUCCESS)
450		{
451	0	result = GlobusSoapMessageErrorCopyFailed(
452		result, NULL, &ds_SignaturePropertyType_choice_qname);
453	0	goto choice_value_destroy_array;
454		}
455
456	0	goto exit;
457
458		fail_deserialize:
459
460		_Id_destroy:
461
462	0	if(instance->_Id)
463		{
464	0	xsd_ID_destroy(
465		instance->_Id);
466	0	instance->_Id = NULL;
467		}
468
469		_Target_destroy:
470
471	0	xsd_anyURI_destroy_contents(
472		&instance->_Target);
473	0	ds_SignaturePropertyType_choice_array_destroy_contents(
474		&instance->choice_value);
475
476		choice_value_destroy_array:
477
478
479		exit:
480
481	0	GlobusSoapMessageDebugExit();
482	0	return result;
483		}
484
485
486
487		globus_result_t
488		ds_SignaturePropertyType_serialize_contents(
489		xsd_QName *                         element_qname, /* ignored */
490		ds_SignaturePropertyType * inst,
491		globus_soap_message_handle_t        message_handle,
492		globus_xsd_element_options_t        options)
493	0	{
494	0	globus_result_t                     result = GLOBUS_SUCCESS;
495	0	GlobusFuncName(ds_SignaturePropertyType_serialize_contents);
496	0	GlobusSoapMessageDebugEnter();
497
498	0	result = ds_SignaturePropertyType_serialize(
499		NULL,
500		inst,
501		message_handle,
502		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
503	0	if(result != GLOBUS_SUCCESS)
504		{
505	0	result = GlobusSoapMessageErrorSerializeFailed(
506		result, NULL, element_qname);
507		goto exit;
508		}
509
510		exit:
511
512	0	GlobusSoapMessageDebugExit();
513	0	return result;
514		}
515
516
517
518		globus_result_t
519		ds_SignaturePropertyType_serialize(
520		xsd_QName *                         element_qname,
521		ds_SignaturePropertyType * instance,
522		globus_soap_message_handle_t        message_handle,
523		globus_xsd_element_options_t        options)
524	0	{
525	0	globus_result_t                     result = GLOBUS_SUCCESS;
526	0	xsd_QName                           subelement;
527	0	globus_list_t *                     any_attr_keys = NULL;
528	0	globus_list_t *                     any_attr_keys_iterator = NULL;
529	0	xsd_QName *                         type_attr = NULL;
530	0	char *                              prefix = NULL;
531	0	int                                 prefix_created;
532	0	int                                 define_prefix = 0;
533	0	int                                 save_options = options;
534
535	0	GlobusFuncName(ds_SignaturePropertyType_serialize);
536	0	GlobusSoapMessageDebugEnter();
537
538
539	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
540		{
541		/* serialize ds_SignaturePropertyType element */
542
543	0	result = globus_soap_message_invoke_ns_callouts(
544		message_handle,
545		element_qname,
546		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_SET,
547		&options);
548	0	if(result != GLOBUS_SUCCESS)
549		{
550	0	result = GlobusSoapMessageErrorSerializeFailed(
551		result, NULL, element_qname);
552	0	goto exit;
553		}
554
555	0	result = globus_soap_message_element_ns_set(
556		message_handle,
557		element_qname->Namespace,
558		&options);
559	0	if(result != GLOBUS_SUCCESS)
560		{
561	0	result = GlobusSoapMessageErrorSerializeFailed(
562		result, NULL, element_qname);
563	0	goto exit;
564		}
565
566	0	if(instance->_Id)
567		{
568
569	0	result = globus_soap_message_attribute_ns_set(
570		message_handle,
571		NULL,
572		&options);
573
574	0	if(result != GLOBUS_SUCCESS)
575		{
576	0	xsd_QName               error_qname;
577	0	error_qname.local = prefix;
578	0	error_qname.Namespace = "";
579	0	result = GlobusSoapMessageErrorSerializeFailed(result,
580		NULL,
581		&error_qname);
582	0	goto exit;
583		}
584
585
586		}
587
588	0	result = globus_soap_message_attribute_ns_set(
589		message_handle,
590		NULL,
591		&options);
592
593	0	if(result != GLOBUS_SUCCESS)
594		{
595	0	xsd_QName               error_qname;
596	0	error_qname.local = prefix;
597	0	error_qname.Namespace = "";
598	0	result = GlobusSoapMessageErrorSerializeFailed(result,
599		NULL,
600		&error_qname);
601	0	goto exit;
602		}
603
604
605	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
606		!globus_soap_message_serialize_is_c14n_subset(message_handle))
607		{
608	0	result = globus_soap_message_attribute_ns_set(
609		message_handle,
610		"http://www.w3.org/2001/XMLSchema-instance",
611		&options);
612	0	if(result != GLOBUS_SUCCESS)
613		{
614	0	result = GlobusSoapMessageErrorSerializeFailed(
615		result, NULL, element_qname);
616	0	goto exit;
617		}
618
619	0	result = globus_soap_message_attribute_ns_set(
620		message_handle,
621		ds_SignaturePropertyType_qname.Namespace,
622		&options);
623	0	if(result != GLOBUS_SUCCESS)
624		{
625	0	result = GlobusSoapMessageErrorSerializeFailed(
626		result, NULL, element_qname);
627	0	goto exit;
628		}
629		}
630
631	0	result = globus_soap_message_invoke_callouts(
632		message_handle,
633		element_qname,
634		GLOBUS_SOAP_MESSAGE_CALLOUT_BEGIN);
635	0	if(result != GLOBUS_SUCCESS)
636		{
637	0	result = GlobusSoapMessageErrorSerializeFailed(
638		result, NULL, element_qname);
639	0	goto exit;
640		}
641
642	0	result = globus_soap_message_serialize_element(
643		message_handle,
644		element_qname,
645		options,
646		&ds_SignaturePropertyType_qname);
647	0	if(result != GLOBUS_SUCCESS)
648		{
649	0	result = GlobusSoapMessageErrorSerializeFailed(
650		result, NULL, element_qname);
651	0	goto exit;
652		}
653
654	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
655		!globus_soap_message_serialize_is_c14n_subset(message_handle))
656		{
657	0	xsd_QName_init(&type_attr);
658
659	0	type_attr->local = globus_libc_strdup("type");
660	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
661		}
662
663		/* serialize namespaces */
664
665	0	result = globus_soap_message_invoke_ns_callouts(
666		message_handle,
667		element_qname,
668		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_ADD,
669		&options);
670	0	if(result != GLOBUS_SUCCESS)
671		{
672	0	result = GlobusSoapMessageErrorSerializeFailed(
673		result, NULL, element_qname);
674	0	goto exit;
675		}
676
677	0	result = globus_soap_message_element_ns_add(
678		message_handle,
679		element_qname->Namespace,
680		&options);
681	0	if(result != GLOBUS_SUCCESS)
682		{
683	0	result = GlobusSoapMessageErrorSerializeFailed(
684		result, NULL, element_qname);
685	0	goto exit;
686		}
687
688	0	if(instance->_Id)
689		{
690
691	0	result = globus_soap_message_attribute_ns_add(
692		message_handle,
693		NULL,
694		&options);
695
696	0	if(result != GLOBUS_SUCCESS)
697		{
698	0	xsd_QName               error_qname;
699	0	error_qname.local = prefix;
700	0	error_qname.Namespace = "";
701	0	result = GlobusSoapMessageErrorSerializeFailed(result,
702		NULL,
703		&error_qname);
704	0	goto exit;
705		}
706
707
708		}
709
710	0	result = globus_soap_message_attribute_ns_add(
711		message_handle,
712		NULL,
713		&options);
714
715	0	if(result != GLOBUS_SUCCESS)
716		{
717	0	xsd_QName               error_qname;
718	0	error_qname.local = prefix;
719	0	error_qname.Namespace = "";
720	0	result = GlobusSoapMessageErrorSerializeFailed(result,
721		NULL,
722		&error_qname);
723	0	goto exit;
724		}
725
726
727	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
728		!globus_soap_message_serialize_is_c14n_subset(message_handle))
729		{
730	0	result = globus_soap_message_attribute_ns_add(
731		message_handle,
732		"http://www.w3.org/2001/XMLSchema-instance",
733		&options);
734	0	if(result != GLOBUS_SUCCESS)
735		{
736	0	result = GlobusSoapMessageErrorSerializeFailed(
737		result, NULL, element_qname);
738	0	goto exit;
739		}
740
741	0	result = globus_soap_message_attribute_ns_add(
742		message_handle,
743		ds_SignaturePropertyType_qname.Namespace,
744		&options);
745	0	if(result != GLOBUS_SUCCESS)
746		{
747	0	result = GlobusSoapMessageErrorSerializeFailed(
748		result, NULL, element_qname);
749	0	goto exit;
750		}
751		}
752
753		/* serialize attributes */
754
755	0	subelement.Namespace = "";
756	0	subelement.local = "Id";
757
758	0	if(instance->_Id)
759		{
760
761	0	result = xsd_ID_serialize_attribute(
762		&subelement,
763		instance->_Id,
764		message_handle,
765		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
766	0	if(result != GLOBUS_SUCCESS)
767		{
768	0	result = GlobusSoapMessageErrorSerializeFailed(result,
769		NULL,
770		element_qname);
771	0	goto exit;
772		}
773
774		}
775
776	0	subelement.Namespace = "";
777	0	subelement.local = "Target";
778
779	0	result = xsd_anyURI_serialize_attribute(
780		&subelement,
781		&instance->_Target,
782		message_handle,
783		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
784	0	if(result != GLOBUS_SUCCESS)
785		{
786	0	result = GlobusSoapMessageErrorSerializeFailed(result,
787		NULL,
788		element_qname);
789	0	goto exit;
790		}
791
792	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
793		!globus_soap_message_serialize_is_c14n_subset(message_handle))
794		{
795	0	result = globus_soap_message_serialize_QName_attribute(
796		message_handle,
797		type_attr,
798		&ds_SignaturePropertyType_qname);
799	0	if(result != GLOBUS_SUCCESS)
800		{
801	0	result = GlobusSoapMessageErrorSerializeFailed(
802		result, NULL, element_qname);
803	0	goto exit;
804		}
805		}
806
807
808	0	result = globus_soap_message_invoke_callouts(
809		message_handle,
810		element_qname,
811		GLOBUS_SOAP_MESSAGE_CALLOUT_ATTR);
812	0	if(result != GLOBUS_SUCCESS)
813		{
814	0	result = GlobusSoapMessageErrorSerializeFailed(
815		result, NULL, element_qname);
816	0	goto exit;
817		}
818		}
819
820	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
821		{
822	0	result = globus_soap_message_serialize_element_begin_close(
823		message_handle);
824	0	if(result != GLOBUS_SUCCESS)
825		{
826	0	result = GlobusSoapMessageErrorSerializeFailed(
827		result, NULL, element_qname);
828	0	goto exit;
829		}
830		}
831	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
832
833		/* serialize contents of type */
834
835	0	subelement.local = "choice_value";
836	0	subelement.Namespace = NULL;
837
838	0	result = GlobusXSDArrayCheckLowerBounds(
839		1,
840		instance->choice_value.length,
841		"choice_value");
842	0	if(result != GLOBUS_SUCCESS)
843		{
844	0	result = GlobusSoapMessageErrorSerializeFailed(
845		result, NULL, &ds_SignaturePropertyType_choice_qname);
846	0	goto exit;
847		}
848
849	0	result = ds_SignaturePropertyType_choice_array_serialize(
850		&subelement,
851		&instance->choice_value,
852		message_handle,
853		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
854	0	if(result != GLOBUS_SUCCESS)
855		{
856	0	result = GlobusSoapMessageErrorSerializeFailed(
857		result, NULL, &ds_SignaturePropertyType_choice_qname);
858	0	goto exit;
859		}
860
861	0	options = save_options;
862
863	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
864		{
865		/* add end element */
866	0	result = globus_soap_message_serialize_element_end(
867		message_handle,
868		element_qname,
869		options,
870		&ds_SignaturePropertyType_qname);
871	0	if(result != GLOBUS_SUCCESS)
872		{
873	0	result = GlobusSoapMessageErrorSerializeFailed(
874		result, NULL, element_qname);
875	0	goto exit;
876		}
877
878	0	globus_soap_message_element_ns_remove(
879		message_handle,
880		element_qname->Namespace,
881		&options);
882
883		/* remove namespace/prefix mappings for these types */
884
885	0	if(instance->_Id)
886		{
887
888	0	globus_soap_message_attribute_ns_remove(
889		message_handle,
890		NULL,
891		&options);
892
893		}
894
895	0	globus_soap_message_attribute_ns_remove(
896		message_handle,
897		NULL,
898		&options);
899
900	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
901		!globus_soap_message_serialize_is_c14n_subset(message_handle))
902		{
903	0	globus_soap_message_attribute_ns_remove(
904		message_handle,
905		"http://www.w3.org/2001/XMLSchema-instance",
906		&options);
907
908	0	globus_soap_message_attribute_ns_remove(
909		message_handle,
910		ds_SignaturePropertyType_qname.Namespace,
911		&options);
912		}
913
914	0	result = globus_soap_message_invoke_ns_callouts(
915		message_handle,
916		element_qname,
917		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_REMOVE,
918		&options);
919	0	if(result != GLOBUS_SUCCESS)
920		{
921	0	result  = GlobusSoapMessageErrorSerializeFailed(
922		result, NULL, element_qname);
923	0	goto exit;
924		}
925
926	0	result = globus_soap_message_invoke_callouts(
927		message_handle,
928		element_qname,
929		GLOBUS_SOAP_MESSAGE_CALLOUT_END);
930	0	if(result != GLOBUS_SUCCESS)
931		{
932	0	result = GlobusSoapMessageErrorSerializeFailed(
933		result, NULL, element_qname);
934		goto exit;
935		}
936		}
937
938		exit:
939	0	if (type_attr)
940		{
941	0	xsd_QName_destroy(type_attr);
942		}
943
944	0	if(any_attr_keys)
945		{
946	0	globus_list_free(any_attr_keys);
947		}
948
949	0	GlobusSoapMessageDebugExit();
950	0	return result;
951		}
952
953
954
955		globus_result_t
956		ds_SignaturePropertyType_deserialize_contents(
957		xsd_QName *                         element_qname, /* ignored */
958		ds_SignaturePropertyType * inst,
959		globus_soap_message_handle_t        message_handle,
960		globus_xsd_element_options_t        options)
961	0	{
962	0	globus_result_t                     result = GLOBUS_SUCCESS;
963	0	GlobusFuncName(ds_SignaturePropertyType_deserialize_contents);
964	0	GlobusSoapMessageDebugEnter();
965
966	0	result = ds_SignaturePropertyType_deserialize(
967		NULL,
968		inst,
969		message_handle,
970		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
971	0	if(result != GLOBUS_SUCCESS)
972		{
973	0	result = GlobusSoapMessageErrorDeserializeFailed(
974		result, element_qname);
975		goto exit;
976		}
977
978		exit:
979
980	0	GlobusSoapMessageDebugExit();
981	0	return result;
982		}
983
984
985
986		globus_result_t
987		ds_SignaturePropertyType_deserialize(
988		xsd_QName *                         element_qname,
989		ds_SignaturePropertyType * instance,
990		globus_soap_message_handle_t        message_handle,
991		globus_xsd_element_options_t        options)
992	0	{
993	0	globus_result_t                     result = GLOBUS_SUCCESS;
994	0	xsd_QName                           subelement;
995	0	GlobusFuncName(ds_SignaturePropertyType_deserialize);
996	0	GlobusSoapMessageDebugEnter();
997
998
999	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1000		{
1001	0	result = globus_soap_message_deserialize_element(
1002		message_handle, element_qname);
1003	0	if(result != GLOBUS_SUCCESS)
1004		{
1005	0	result = GlobusSoapMessageErrorDeserializeFailed(
1006		result, element_qname);
1007	0	goto exit;
1008		}
1009
1010	0	subelement.Namespace = "";
1011	0	subelement.local = "Id";
1012
1013	0	result = xsd_ID_deserialize_attribute_pointer(
1014		&subelement,
1015		&instance->_Id,
1016		message_handle,
1017		0);
1018	0	if(result != GLOBUS_SUCCESS)
1019		{
1020	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1021	0	goto _Id_destroy;
1022		}
1023
1024
1025	0	subelement.Namespace = "";
1026	0	subelement.local = "Target";
1027
1028	0	result = xsd_anyURI_deserialize_attribute(
1029		&subelement,
1030		&instance->_Target,
1031		message_handle,
1032		0);
1033	0	if(result != GLOBUS_SUCCESS)
1034		{
1035	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1036	0	goto _Target_destroy;
1037		}
1038
1039
1040	0	result = globus_soap_message_deserialize_element_begin_close(
1041		message_handle);
1042	0	if(result != GLOBUS_SUCCESS)
1043		{
1044	0	result = GlobusSoapMessageErrorDeserializeFailed(
1045		result, element_qname);
1046	0	goto fail_deserialize;
1047		}
1048		}
1049
1050	0	subelement.local = "choice_value";
1051	0	subelement.Namespace = NULL;
1052
1053	0	result = ds_SignaturePropertyType_choice_array_deserialize(
1054		&subelement,
1055		&instance->choice_value,
1056		message_handle,
1057		0);
1058	0	if(result != GLOBUS_SUCCESS)
1059		{
1060	0	result = GlobusSoapMessageErrorDeserializeFailed(
1061		result,
1062		(&subelement));
1063	0	goto choice_value_destroy_array;
1064		}
1065
1066	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1067		{
1068	0	result = globus_soap_message_deserialize_element_end(
1069		message_handle,
1070		element_qname);
1071	0	if(result != GLOBUS_SUCCESS)
1072		{
1073	0	result = GlobusSoapMessageErrorDeserializeFailed(
1074		result, element_qname);
1075		goto fail_deserialize;
1076		}
1077		}
1078
1079	0	goto exit;
1080
1081		fail_deserialize:
1082
1083		_Id_destroy:
1084
1085	0	if(instance->_Id)
1086		{
1087	0	xsd_ID_destroy(
1088		instance->_Id);
1089	0	instance->_Id = NULL;
1090		}
1091
1092		_Target_destroy:
1093
1094	0	xsd_anyURI_destroy_contents(
1095		&instance->_Target);
1096	0	ds_SignaturePropertyType_choice_array_destroy_contents(
1097		&instance->choice_value);
1098
1099		choice_value_destroy_array:
1100
1101
1102		exit:
1103
1104	0	GlobusSoapMessageDebugExit();
1105	0	return result;
1106		}
1107
1108
1109
1110		globus_result_t
1111		ds_SignaturePropertyType_deserialize_pointer(
1112		xsd_QName *                         element_qname,
1113		ds_SignaturePropertyType ** ip,
1114		globus_soap_message_handle_t        message_handle,
1115		globus_xsd_element_options_t        options)
1116	0	{
1117	0	ds_SignaturePropertyType * instance = NULL;
1118	0	globus_result_t                     result = GLOBUS_SUCCESS;
1119	0	xsd_QName                           subelement;
1120	0	int                                 found_attrs = 0;
1121	0	int                                 empty_element = 0;
1122	0	GlobusFuncName(ds_SignaturePropertyType_deserialize_pointer);
1123	0	GlobusSoapMessageDebugEnter();
1124
1125	0	*ip = NULL;
1126
1127	0	result = globus_soap_message_deserialize_element(
1128		message_handle, element_qname);
1129	0	if(result != GLOBUS_SUCCESS &&
1130		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1131		GlobusSoapMessageStatusFailedElementCheck(result) ||
1132		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1133		{
1134	0	*ip = NULL;
1135	0	result = GLOBUS_SUCCESS;
1136	0	goto exit;
1137		}
1138
1139	0	if(result != GLOBUS_SUCCESS)
1140		{
1141	0	result = GlobusSoapMessageErrorDeserializeFailed(
1142		result, element_qname);
1143	0	goto exit;
1144		}
1145
1146	0	if(globus_soap_message_deserialize_element_is_empty(
1147		message_handle))
1148		{
1149	0	empty_element = 1;
1150		}
1151
1152
1153
1154	0	result = ds_SignaturePropertyType_init(&instance);
1155	0	if(result != GLOBUS_SUCCESS)
1156		{
1157	0	result = GlobusSoapMessageErrorDeserializeFailed(
1158		result, element_qname);
1159	0	goto exit;
1160		}
1161
1162
1163	0	subelement.Namespace = "";
1164	0	subelement.local = "Id";
1165
1166	0	result = xsd_ID_deserialize_attribute_pointer(
1167		&subelement,
1168		&instance->_Id,
1169		message_handle,
1170		0);
1171	0	if(result != GLOBUS_SUCCESS)
1172		{
1173	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1174	0	goto _Id_destroy;
1175		}
1176
1177
1178	0	if(instance->_Id)
1179		{
1180	0	found_attrs++;
1181		}
1182
1183	0	subelement.Namespace = "";
1184	0	subelement.local = "Target";
1185
1186	0	result = xsd_anyURI_deserialize_attribute(
1187		&subelement,
1188		&instance->_Target,
1189		message_handle,
1190		0);
1191	0	if(result != GLOBUS_SUCCESS)
1192		{
1193	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1194	0	goto _Target_destroy;
1195		}
1196
1197	0	found_attrs++;
1198
1199
1200	0	if(empty_element)
1201		{
1202	0	result = globus_soap_message_deserialize_element_end(
1203		message_handle,
1204		element_qname);
1205	0	if(result != GLOBUS_SUCCESS)
1206		{
1207	0	result = GlobusSoapMessageErrorDeserializeFailed(
1208		result, element_qname);
1209	0	goto fail_deserialize;
1210		}
1211
1212	0	*ip = instance;
1213	0	goto exit;
1214		}
1215
1216	0	result = globus_soap_message_deserialize_element_begin_close(
1217		message_handle);
1218	0	if(result != GLOBUS_SUCCESS)
1219		{
1220	0	result = GlobusSoapMessageErrorDeserializeFailed(
1221		result, element_qname);
1222	0	goto exit;
1223		}
1224
1225
1226	0	subelement.local = "choice_value";
1227	0	subelement.Namespace = NULL;
1228
1229	0	result = ds_SignaturePropertyType_choice_array_deserialize(
1230		&subelement,
1231		&instance->choice_value,
1232		message_handle,
1233		0);
1234	0	if(result != GLOBUS_SUCCESS)
1235		{
1236	0	result = GlobusSoapMessageErrorDeserializeFailed(
1237		result,
1238		(&subelement));
1239	0	goto choice_value_destroy_array;
1240		}
1241
1242
1243	0	result = globus_soap_message_deserialize_element_end(
1244		message_handle,
1245		element_qname);
1246	0	if(result != GLOBUS_SUCCESS)
1247		{
1248	0	result = GlobusSoapMessageErrorDeserializeFailed(
1249		result, element_qname);
1250	0	goto fail_deserialize;
1251		}
1252
1253	0	*ip = instance;
1254
1255	0	goto exit;
1256
1257		fail_deserialize:
1258
1259		_Id_destroy:
1260
1261	0	if(instance->_Id)
1262		{
1263	0	xsd_ID_destroy(
1264		instance->_Id);
1265	0	instance->_Id = NULL;
1266		}
1267
1268		_Target_destroy:
1269
1270	0	xsd_anyURI_destroy_contents(
1271		&instance->_Target);
1272	0	ds_SignaturePropertyType_choice_array_destroy_contents(
1273		&instance->choice_value);
1274
1275		choice_value_destroy_array:
1276
1277		exit:
1278
1279	0	GlobusSoapMessageDebugExit();
1280	0	return result;
1281		}
1282
1283
1284		globus_result_t
1285		ds_SignaturePropertyType_array_init_contents(
1286		ds_SignaturePropertyType_array * array)
1287	0	{
1288	0	GlobusFuncName(ds_SignaturePropertyType_array_init_contents);
1289	0	GlobusSoapMessageDebugEnter();
1290
1291	0	memset(array, 0, sizeof(ds_SignaturePropertyType_array));
1292
1293	0	GlobusSoapMessageDebugExit();
1294	0	return GLOBUS_SUCCESS;
1295		}
1296
1297		globus_result_t
1298		ds_SignaturePropertyType_array_init(
1299		ds_SignaturePropertyType_array ** arr)
1300	0	{
1301	0	ds_SignaturePropertyType_array * array;
1302	0	globus_result_t                     result;
1303	0	GlobusFuncName(ds_SignaturePropertyType_array_init);
1304	0	GlobusSoapMessageDebugEnter();
1305
1306	0	array = (ds_SignaturePropertyType_array *)
1307		globus_malloc(sizeof(ds_SignaturePropertyType_array));
1308	0	if(!array)
1309		{
1310	0	result = GlobusSoapMessageErrorOutOfMemory;
1311	0	goto exit;
1312		}
1313
1314	0	result = ds_SignaturePropertyType_array_init_contents(array);
1315	0	if(result != GLOBUS_SUCCESS)
1316		{
1317	0	globus_free(array);
1318	0	array = NULL;
1319
1320		}
1321
1322	0	*arr = array;
1323
1324		exit:
1325	0	GlobusSoapMessageDebugExit();
1326	0	return result;
1327		}
1328
1329		void
1330		ds_SignaturePropertyType_array_destroy_contents(
1331		ds_SignaturePropertyType_array * array)
1332	0	{
1333	0	int                                 i = 0;
1334	0	GlobusFuncName(ds_SignaturePropertyType_array_destroy_contents);
1335	0	GlobusSoapMessageDebugEnter();
1336
1337	0	for(; i < array->length; ++i)
1338		{
1339	0	ds_SignaturePropertyType_destroy_contents(&array->elements[i]);
1340		}
1341
1342	0	if(array->elements)
1343		{
1344	0	globus_free(array->elements);
1345	0	array->elements = NULL;
1346		}
1347	0	array->length = 0;
1348
1349	0	GlobusSoapMessageDebugExit();
1350		}
1351
1352		void
1353		ds_SignaturePropertyType_array_destroy(
1354		ds_SignaturePropertyType_array * array)
1355	0	{
1356	0	GlobusFuncName(ds_SignaturePropertyType_array_destroy);
1357	0	GlobusSoapMessageDebugEnter();
1358
1359	0	ds_SignaturePropertyType_array_destroy_contents(array);
1360	0	globus_free(array);
1361
1362	0	GlobusSoapMessageDebugExit();
1363		}
1364
1365		globus_result_t
1366		ds_SignaturePropertyType_array_copy(
1367		ds_SignaturePropertyType_array ** dest_arr,
1368		const ds_SignaturePropertyType_array * src_arr)
1369	0	{
1370	0	ds_SignaturePropertyType_array * array;
1371	0	globus_result_t                     result;
1372	0	GlobusFuncName(ds_SignaturePropertyType_array_copy);
1373	0	GlobusSoapMessageDebugEnter();
1374
1375	0	array = (ds_SignaturePropertyType_array *) globus_malloc(
1376		sizeof(ds_SignaturePropertyType_array));
1377	0	if(!array)
1378		{
1379	0	result = GlobusSoapMessageErrorOutOfMemory;
1380	0	GlobusSoapMessageDebugExit();
1381	0	return result;
1382		}
1383
1384	0	result = ds_SignaturePropertyType_array_copy_contents(array, src_arr);
1385	0	if(result != GLOBUS_SUCCESS)
1386		{
1387	0	globus_free(array);
1388	0	GlobusSoapMessageDebugExit();
1389	0	return result;
1390		}
1391
1392	0	*dest_arr = array;
1393
1394	0	GlobusSoapMessageDebugExit();
1395	0	return GLOBUS_SUCCESS;
1396		}
1397
1398		globus_result_t
1399		ds_SignaturePropertyType_array_copy_contents(
1400		ds_SignaturePropertyType_array * dest_arr,
1401		const ds_SignaturePropertyType_array * src_arr)
1402	0	{
1403	0	int                                 i;
1404	0	globus_result_t                     result = GLOBUS_SUCCESS;
1405	0	GlobusFuncName(ds_SignaturePropertyType_array_copy_contents);
1406	0	GlobusSoapMessageDebugEnter();
1407
1408	0	dest_arr->length = src_arr->length;
1409	0	if(dest_arr->length > 0)
1410		{
1411	0	dest_arr->elements = (ds_SignaturePropertyType *) malloc(
1412		sizeof(ds_SignaturePropertyType) * dest_arr->length);
1413	0	if(!dest_arr->elements)
1414		{
1415	0	result = GlobusSoapMessageErrorOutOfMemory;
1416	0	GlobusSoapMessageDebugExit();
1417	0	return result;
1418		}
1419		}
1420		else
1421		{
1422	0	dest_arr->elements = NULL;
1423		}
1424
1425	0	for(i = 0; i < dest_arr->length; i++)
1426		{
1427	0	result = ds_SignaturePropertyType_copy_contents(
1428		&dest_arr->elements[i], &src_arr->elements[i]);
1429	0	if(result != GLOBUS_SUCCESS)
1430		{
1431	0	while(i--)
1432		{
1433	0	ds_SignaturePropertyType_destroy_contents(&dest_arr->elements[i]);
1434		}
1435
1436	0	globus_free(dest_arr->elements);
1437	0	dest_arr->elements = NULL;
1438	0	dest_arr->length = 0;
1439	0	break;
1440		}
1441		}
1442
1443	0	GlobusSoapMessageDebugExit();
1444	0	return result;
1445		}
1446
1447		ds_SignaturePropertyType *
1448		ds_SignaturePropertyType_array_push(
1449		ds_SignaturePropertyType_array * array)
1450	0	{
1451	0	GlobusFuncName(ds_SignaturePropertyType_array_push);
1452	0	GlobusSoapMessageDebugEnter();
1453
1454	0	array->elements = realloc(array->elements,
1455		sizeof(ds_SignaturePropertyType) *
1456		(array->length + 1));
1457	0	memset(&array->elements[array->length], 0, sizeof(ds_SignaturePropertyType));
1458	0	array->length++;
1459
1460	0	GlobusSoapMessageDebugExit();
1461	0	return (&array->elements[array->length - 1]);
1462		}
1463
1464		void *
1465		ds_SignaturePropertyType_array_push_wrapper(
1466		void * array)
1467	0	{
1468	0	return (void *) ds_SignaturePropertyType_array_push((ds_SignaturePropertyType_array *) array);
1469		}
1470
1471		globus_result_t
1472		ds_SignaturePropertyType_array_serialize(
1473		xsd_QName *                         element_qname,
1474		ds_SignaturePropertyType_array * array,
1475		globus_soap_message_handle_t        message,
1476		globus_xsd_element_options_t        options)
1477	0	{
1478	0	globus_result_t                     result = GLOBUS_SUCCESS;
1479	0	int                                 i = 0;
1480	0	GlobusFuncName(ds_SignaturePropertyType_array_serialize);
1481	0	GlobusSoapMessageDebugEnter();
1482
1483	0	for(; i < array->length; ++i)
1484		{
1485	0	result = ds_SignaturePropertyType_serialize(
1486		element_qname,
1487		&array->elements[i],
1488		message,
1489		options);
1490	0	if(result != GLOBUS_SUCCESS)
1491		{
1492	0	goto exit;
1493		}
1494		}
1495
1496		exit:
1497
1498	0	GlobusSoapMessageDebugExit();
1499	0	return result;
1500		}
1501
1502		globus_result_t
1503		ds_SignaturePropertyType_array_deserialize(
1504		xsd_QName *                         element_qname,
1505		ds_SignaturePropertyType_array * array,
1506		globus_soap_message_handle_t        message,
1507		globus_xsd_element_options_t        options)
1508	0	{
1509	0	globus_result_t                     result = GLOBUS_SUCCESS;
1510	0	int                                 i = 0;
1511	0	int                                 pre_length;
1512	0	GlobusFuncName(ds_SignaturePropertyType_array_deserialize);
1513	0	GlobusSoapMessageDebugEnter();
1514
1515	0	pre_length = array->length;
1516
1517	0	for(i = 0; i < pre_length; ++i)
1518		{
1519	0	result = ds_SignaturePropertyType_deserialize(
1520		element_qname,
1521		&array->elements[i],
1522		message,
1523		options);
1524	0	if(result != GLOBUS_SUCCESS)
1525		{
1526	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1527		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1528		GlobusSoapMessageStatusFailedWithTextCheck(result))
1529		{
1530	0	result = GLOBUS_SUCCESS;
1531	0	break;
1532		}
1533
1534	0	result = GlobusSoapMessageErrorDeserializeFailed(
1535		result, element_qname);
1536	0	goto exit;
1537		}
1538		}
1539
1540	0	while(result == GLOBUS_SUCCESS)
1541		{
1542	0	ds_SignaturePropertyType                  next;
1543	0	memset(&next, 0, sizeof(ds_SignaturePropertyType));
1544
1545	0	result = ds_SignaturePropertyType_deserialize(
1546		element_qname,
1547		&next,
1548		message,
1549		options);
1550	0	if(result != GLOBUS_SUCCESS)
1551		{
1552	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1553		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1554		GlobusSoapMessageStatusFailedWithTextCheck(result))
1555		{
1556	0	result = GLOBUS_SUCCESS;
1557	0	break;
1558		}
1559
1560	0	result = GlobusSoapMessageErrorDeserializeFailed(
1561		result, element_qname);
1562	0	goto exit;
1563		}
1564
1565	0	array->elements = realloc(
1566		array->elements,
1567		(array->length + 1) * sizeof(ds_SignaturePropertyType));
1568	0	if(!array->elements)
1569		{
1570	0	result = GlobusSoapMessageErrorOutOfMemory;
1571	0	goto exit;
1572		}
1573	0	array->elements[array->length] = next;
1574	0	array->length++;
1575	0	++i;
1576		}
1577
1578		exit:
1579
1580	0	if(result != GLOBUS_SUCCESS)
1581		{
1582	0	int                             di = 0;
1583	0	for(; di < i; ++di)
1584		{
1585	0	ds_SignaturePropertyType_destroy_contents(
1586		&array->elements[di]);
1587	0	memset(&array->elements[di], 0, sizeof(ds_SignaturePropertyType));
1588		}
1589		}
1590
1591	0	GlobusSoapMessageDebugExit();
1592	0	return result;