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