1		/*
2		* Copyright 1999-2006 University of Chicago
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17
18		/*
19		* This file is automatically generated by the Globus WSDLtoC converter
20		*/
21
22		#include "xsd_QName.h"
23		#include "globus_soap_message.h"
24		#include "globus_xsd_type_info.h"
25		#include "ds_RetrievalMethodType.h"
26
27		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
28		xsd_QName ds_RetrievalMethodType_qname =
29		{
30		DS_RETRIEVALMETHODTYPE_NS,
31		DS_RETRIEVALMETHODTYPE_LOCAL
32		};
33		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
34
35		globus_result_t
36		ds_RetrievalMethodType_serialize_wrapper(
37		const xsd_QName *                   element_qname,
38		const void *                        instance,
39		globus_soap_message_handle_t        message_handle,
40		globus_xsd_element_options_t        options)
41	0	{
42	0	return ds_RetrievalMethodType_serialize(
43		element_qname,
44		(const ds_RetrievalMethodType *) instance,
45		message_handle, options);
46		}
47
48		globus_result_t
49		ds_RetrievalMethodType_deserialize_pointer_wrapper(
50		const xsd_QName *                   element_qname,
51		void **                             ip,
52		globus_soap_message_handle_t        message_handle,
53		globus_xsd_element_options_t        options)
54	0	{
55	0	return ds_RetrievalMethodType_deserialize_pointer(
56		element_qname,
57		(ds_RetrievalMethodType **) ip,
58		message_handle, options);
59		}
60
61		globus_result_t
62		ds_RetrievalMethodType_init_wrapper(void **object)
63	0	{
64	0	return ds_RetrievalMethodType_init(
65		(ds_RetrievalMethodType **) object);
66		}
67
68		void
69		ds_RetrievalMethodType_destroy_wrapper(
70		void *                          object)
71	0	{
72	0	ds_RetrievalMethodType_destroy(
73		(ds_RetrievalMethodType *) object);
74		}
75
76		globus_result_t
77		ds_RetrievalMethodType_copy_wrapper(
78		void **                         dest_obj,
79		const void *                    src_obj)
80	0	{
81	0	return ds_RetrievalMethodType_copy(
82		(ds_RetrievalMethodType **) dest_obj,
83		(ds_RetrievalMethodType *) src_obj);
84		}
85
86		globus_result_t
87		ds_RetrievalMethodType_init_contents_wrapper(void *object)
88	0	{
89	0	return ds_RetrievalMethodType_init_contents(
90		(ds_RetrievalMethodType *) object);
91		}
92
93		void
94		ds_RetrievalMethodType_destroy_contents_wrapper(
95		void *                          object)
96	0	{
97	0	ds_RetrievalMethodType_destroy_contents(
98		(ds_RetrievalMethodType *) object);
99		}
100
101		globus_result_t
102		ds_RetrievalMethodType_copy_contents_wrapper(
103		void *                          dest_obj,
104		const void *                    src_obj)
105	0	{
106	0	return ds_RetrievalMethodType_copy_contents(
107		(ds_RetrievalMethodType *) dest_obj,
108		(const ds_RetrievalMethodType *) src_obj);
109		}
110
111		globus_result_t
112		ds_RetrievalMethodType_serialize_contents_wrapper(
113		const xsd_QName *                   element_qname,
114		const void *                        instance,
115		globus_soap_message_handle_t        message_handle,
116		globus_xsd_element_options_t        options)
117	0	{
118	0	return ds_RetrievalMethodType_serialize_contents(
119		element_qname,
120		(ds_RetrievalMethodType *) instance,
121		message_handle, options);
122		}
123
124		globus_result_t
125		ds_RetrievalMethodType_deserialize_contents_wrapper(
126		const xsd_QName *                   element_qname,
127		void **                             instance,
128		globus_soap_message_handle_t        message_handle,
129		globus_xsd_element_options_t        options)
130	0	{
131	0	globus_result_t                     result;
132	0	GlobusFuncName(ds_RetrievalMethodType_deserialize_contents_wrapper);
133	0	GlobusSoapMessageDebugEnter();
134
135	0	if(!*instance)
136		{
137	0	result = ds_RetrievalMethodType_init(
138		(ds_RetrievalMethodType **)instance);
139	0	if(result != GLOBUS_SUCCESS)
140		{
141	0	goto error;
142		}
143		}
144
145	0	result = ds_RetrievalMethodType_deserialize_contents(
146		element_qname,
147		*(ds_RetrievalMethodType **)instance,
148		message_handle, options);
149		error:
150	0	GlobusSoapMessageDebugExit();
151	0	return result;
152		}
153
154		globus_result_t
155		ds_RetrievalMethodType_array_serialize_wrapper(
156		const xsd_QName *               element,
157		const void *                    instance,
158		globus_soap_message_handle_t    message,
159		globus_xsd_element_options_t    options)
160	0	{
161	0	return ds_RetrievalMethodType_array_serialize(
162		element,
163		(ds_RetrievalMethodType_array *) instance,
164		message, options);
165		}
166
167		globus_result_t
168		ds_RetrievalMethodType_array_deserialize_wrapper(
169		const xsd_QName *                   element_qname,
170		void **                             inst,
171		globus_soap_message_handle_t        message,
172		globus_xsd_element_options_t        options)
173	0	{
174	0	if(!*inst)
175		{
176	0	globus_result_t                 result;
177
178	0	result = ds_RetrievalMethodType_array_init(
179		(ds_RetrievalMethodType_array **)inst);
180	0	if(result != GLOBUS_SUCCESS)
181		{
182	0	return result;
183		}
184		}
185
186	0	return ds_RetrievalMethodType_array_deserialize(
187		element_qname,
188		*(ds_RetrievalMethodType_array **) inst,
189		message, options);
190		}
191
192		globus_result_t
193		ds_RetrievalMethodType_array_init_wrapper(
194		void **                             arr)
195	0	{
196	0	return ds_RetrievalMethodType_array_init(
197		(ds_RetrievalMethodType_array **) arr);
198		}
199
200		void
201		ds_RetrievalMethodType_array_destroy_wrapper(
202		void *                              arr)
203	0	{
204	0	ds_RetrievalMethodType_array_destroy(
205		(ds_RetrievalMethodType_array *) arr);
206		}
207
208		globus_result_t
209		ds_RetrievalMethodType_array_copy_wrapper(
210		void **                             dest_arr,
211		const void *                        src_arr)
212	0	{
213	0	return ds_RetrievalMethodType_array_copy(
214		(ds_RetrievalMethodType_array **) dest_arr,
215		(const ds_RetrievalMethodType_array *) src_arr);
216		}
217
218		globus_result_t
219		ds_RetrievalMethodType_array_init_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	return ds_RetrievalMethodType_array_init_contents(
223		(ds_RetrievalMethodType_array *) arr);
224		}
225
226		void
227		ds_RetrievalMethodType_array_destroy_contents_wrapper(
228		void *                              arr)
229	0	{
230	0	ds_RetrievalMethodType_array_destroy_contents(
231		(ds_RetrievalMethodType_array *) arr);
232		}
233
234		globus_result_t
235		ds_RetrievalMethodType_array_copy_contents_wrapper(
236		void *                              dest_arr,
237		const void *                        src_arr)
238	0	{
239	0	return ds_RetrievalMethodType_array_copy_contents(
240		(ds_RetrievalMethodType_array *) dest_arr,
241		(const ds_RetrievalMethodType_array *) src_arr);
242		}
243
244		struct globus_xsd_type_info_s ds_RetrievalMethodType_contents_info =
245		{
246		&ds_RetrievalMethodType_qname,
247		ds_RetrievalMethodType_serialize_contents_wrapper,
248		ds_RetrievalMethodType_deserialize_contents_wrapper,
249		ds_RetrievalMethodType_init_wrapper,
250		ds_RetrievalMethodType_destroy_wrapper,
251		ds_RetrievalMethodType_copy_wrapper,
252		ds_RetrievalMethodType_init_contents_wrapper,
253		ds_RetrievalMethodType_destroy_contents_wrapper,
254		ds_RetrievalMethodType_copy_contents_wrapper,
255		sizeof(ds_RetrievalMethodType),
256		NULL,
257		NULL,
258		NULL
259		};
260
261		struct globus_xsd_type_info_s ds_RetrievalMethodType_array_info =
262		{
263		&ds_RetrievalMethodType_qname,
264		ds_RetrievalMethodType_array_serialize_wrapper,
265		ds_RetrievalMethodType_array_deserialize_wrapper,
266		ds_RetrievalMethodType_array_init_wrapper,
267		ds_RetrievalMethodType_array_destroy_wrapper,
268		ds_RetrievalMethodType_array_copy_wrapper,
269		ds_RetrievalMethodType_array_init_contents_wrapper,
270		ds_RetrievalMethodType_array_destroy_contents_wrapper,
271		ds_RetrievalMethodType_array_copy_contents_wrapper,
272		sizeof(ds_RetrievalMethodType),
273		ds_RetrievalMethodType_array_push_wrapper,
274		NULL,
275		NULL
276		};
277
278		struct globus_xsd_type_info_s ds_RetrievalMethodType_info =
279		{
280		&ds_RetrievalMethodType_qname,
281		ds_RetrievalMethodType_serialize_wrapper,
282		ds_RetrievalMethodType_deserialize_pointer_wrapper,
283		ds_RetrievalMethodType_init_wrapper,
284		ds_RetrievalMethodType_destroy_wrapper,
285		ds_RetrievalMethodType_copy_wrapper,
286		ds_RetrievalMethodType_init_contents_wrapper,
287		ds_RetrievalMethodType_destroy_contents_wrapper,
288		ds_RetrievalMethodType_copy_contents_wrapper,
289		sizeof(ds_RetrievalMethodType),
290		NULL,
291		&ds_RetrievalMethodType_contents_info,
292		&ds_RetrievalMethodType_array_info
293		};
294
295		globus_result_t
296		ds_RetrievalMethodType_init_contents(
297		ds_RetrievalMethodType * instance)
298	0	{
299	0	globus_result_t                     result = GLOBUS_SUCCESS;
300	0	GlobusFuncName(ds_RetrievalMethodType_init_contents);
301	0	GlobusSoapMessageDebugEnter();
302
303	0	memset(instance, 0, sizeof(ds_RetrievalMethodType));
304
305	0	GlobusSoapMessageDebugExit();
306	0	return result;
307		}
308
309		globus_result_t
310		ds_RetrievalMethodType_init(
311		ds_RetrievalMethodType ** object)
312	0	{
313	0	ds_RetrievalMethodType * instance;
314	0	globus_result_t                     result = GLOBUS_SUCCESS;
315	0	GlobusFuncName(ds_RetrievalMethodType_init);
316	0	GlobusSoapMessageDebugEnter();
317
318	0	instance = globus_malloc(sizeof(ds_RetrievalMethodType));
319	0	if(!instance)
320		{
321	0	result = GlobusSoapMessageErrorOutOfMemory;
322	0	goto exit;
323		}
324
325	0	memset(instance, 0, sizeof(ds_RetrievalMethodType));
326
327	0	*object = instance;
328
329		exit:
330	0	GlobusSoapMessageDebugExit();
331	0	return result;
332		}
333
334		void
335		ds_RetrievalMethodType_destroy(
336		ds_RetrievalMethodType * instance)
337	0	{
338	0	GlobusFuncName(ds_RetrievalMethodType_destroy);
339	0	GlobusSoapMessageDebugEnter();
340
341	0	if(!instance)
342		{
343	0	goto exit;
344		}
345
346	0	ds_RetrievalMethodType_destroy_contents(instance);
347	0	globus_free(instance);
348
349		exit:
350
351	0	GlobusSoapMessageDebugExit();
352		}
353
354
355		void
356		ds_RetrievalMethodType_destroy_contents(
357		ds_RetrievalMethodType * instance)
358	0	{
359	0	GlobusFuncName(ds_RetrievalMethodType_destroy_contents);
360	0	GlobusSoapMessageDebugEnter();
361
362	0	if(instance)
363		{
364
365
366	0	ds_TransformsType_destroy(instance->Transforms);
367	0	instance->Transforms = NULL;
368
369	0	if(instance->_Type)
370		{
371	0	xsd_anyURI_destroy(
372		instance->_Type);
373	0	instance->_Type = NULL;
374		}
375
376	0	if(instance->_URI)
377		{
378	0	xsd_anyURI_destroy(
379		instance->_URI);
380	0	instance->_URI = NULL;
381		}
382
383		}
384
385	0	GlobusSoapMessageDebugExit();
386		}
387
388
389		globus_result_t
390		ds_RetrievalMethodType_copy(
391		ds_RetrievalMethodType ** dest_obj,
392		const ds_RetrievalMethodType * src_obj)
393	0	{
394	0	globus_result_t                     result = GLOBUS_SUCCESS;
395	0	ds_RetrievalMethodType * instance;
396	0	GlobusFuncName(ds_RetrievalMethodType_copy);
397
398	0	GlobusSoapMessageDebugEnter();
399
400	0	instance = calloc(1, sizeof(ds_RetrievalMethodType));
401	0	if (instance == NULL)
402		{
403	0	GlobusSoapMessageDebugExit();
404	0	return GlobusSoapMessageErrorOutOfMemory;
405		}
406
407	0	result = ds_RetrievalMethodType_copy_contents(instance, src_obj);
408	0	if(result != GLOBUS_SUCCESS)
409		{
410	0	globus_free(instance);
411	0	GlobusSoapMessageDebugExit();
412	0	return GlobusSoapMessageErrorOutOfMemory;
413		}
414
415	0	*dest_obj = instance;
416	0	GlobusSoapMessageDebugExit();
417	0	return result;
418		}
419
420		globus_result_t
421		ds_RetrievalMethodType_copy_contents(
422		ds_RetrievalMethodType * instance,
423		const ds_RetrievalMethodType * src_obj)
424	0	{
425	0	globus_result_t                     result = GLOBUS_SUCCESS;
426	0	GlobusFuncName(ds_RetrievalMethodType_copy_contents);
427
428	0	GlobusSoapMessageDebugEnter();
429
430	0	if(src_obj->_Type)
431		{
432	0	result = xsd_anyURI_copy(
433		&instance->_Type,
434		src_obj->_Type);
435	0	if(result != GLOBUS_SUCCESS)
436		{
437	0	result = GlobusSoapMessageErrorCopyFailed(
438		result, NULL, &xsd_anyURI_qname);
439	0	goto _Type_destroy;
440		}
441		}
442		else
443		{
444	0	instance->_Type = NULL;
445		}
446
447	0	if(src_obj->_URI)
448		{
449	0	result = xsd_anyURI_copy(
450		&instance->_URI,
451		src_obj->_URI);
452	0	if(result != GLOBUS_SUCCESS)
453		{
454	0	result = GlobusSoapMessageErrorCopyFailed(
455		result, NULL, &xsd_anyURI_qname);
456	0	goto _URI_destroy;
457		}
458		}
459		else
460		{
461	0	instance->_URI = NULL;
462		}
463
464	0	if(src_obj->Transforms)
465		{
466	0	result = ds_TransformsType_copy(
467		&instance->Transforms,
468		src_obj->Transforms);
469	0	if(result != GLOBUS_SUCCESS)
470		{
471	0	result = GlobusSoapMessageErrorCopyFailed(
472		result, NULL, &ds_TransformsType_qname);
473	0	goto Transforms_destroy_pointer;
474		}
475		}
476		else
477		{
478	0	instance->Transforms = NULL;
479		}
480
481	0	goto exit;
482
483		fail_deserialize:
484
485		_URI_destroy:
486
487	0	if(instance->_URI)
488		{
489	0	xsd_anyURI_destroy(
490		instance->_URI);
491	0	instance->_URI = NULL;
492		}
493
494		_Type_destroy:
495
496	0	if(instance->_Type)
497		{
498	0	xsd_anyURI_destroy(
499		instance->_Type);
500	0	instance->_Type = NULL;
501		}
502	0	ds_TransformsType_destroy(
503		instance->Transforms);
504	0	instance->Transforms = NULL;
505
506		Transforms_destroy_pointer:
507
508
509		exit:
510
511	0	GlobusSoapMessageDebugExit();
512	0	return result;
513		}
514
515
516
517		globus_result_t
518		ds_RetrievalMethodType_serialize_contents(
519		const xsd_QName *                   element_qname, /* ignored */
520		const ds_RetrievalMethodType *              inst,
521		globus_soap_message_handle_t        message_handle,
522		globus_xsd_element_options_t        options)
523	0	{
524	0	globus_result_t                     result = GLOBUS_SUCCESS;
525	0	GlobusFuncName(ds_RetrievalMethodType_serialize_contents);
526	0	GlobusSoapMessageDebugEnter();
527
528	0	result = ds_RetrievalMethodType_serialize(
529		NULL,
530		inst,
531		message_handle,
532		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
533	0	if(result != GLOBUS_SUCCESS)
534		{
535	0	result = GlobusSoapMessageErrorSerializeFailed(
536		result, NULL, element_qname);
537		goto exit;
538		}
539
540		exit:
541
542	0	GlobusSoapMessageDebugExit();
543	0	return result;
544		}
545
546
547
548		globus_result_t
549		ds_RetrievalMethodType_serialize(
550		const xsd_QName *                   element_qname,
551		const ds_RetrievalMethodType *              instance,
552		globus_soap_message_handle_t        message_handle,
553		globus_xsd_element_options_t        options)
554	0	{
555	0	globus_result_t                     result = GLOBUS_SUCCESS;
556	0	xsd_QName                           subelement;
557	0	globus_list_t *                     any_attr_keys = NULL;
558	0	globus_list_t *                     any_attr_keys_iterator = NULL;
559	0	xsd_QName *                         type_attr = NULL;
560
561	0	char *                              prefix = NULL;
562	0	int                                 prefix_created;
563	0	int                                 define_prefix = 0;
564	0	int                                 save_options = options;
565
566	0	GlobusFuncName(ds_RetrievalMethodType_serialize);
567	0	GlobusSoapMessageDebugEnter();
568
569
570	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
571		{
572		/* serialize ds_RetrievalMethodType element */
573	0	result = globus_soap_message_element_ns_set(
574		message_handle,
575		element_qname,
576		element_qname->Namespace,
577		&options);
578	0	if(result != GLOBUS_SUCCESS)
579		{
580	0	result = GlobusSoapMessageErrorSerializeFailed(
581		result, NULL, element_qname);
582	0	goto exit;
583		}
584
585	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
586		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
587		{
588	0	result = globus_soap_message_attribute_ns_set(
589		message_handle,
590		element_qname,
591		"http://www.w3.org/2001/XMLSchema-instance",
592		&options);
593	0	if(result != GLOBUS_SUCCESS)
594		{
595	0	result = GlobusSoapMessageErrorSerializeFailed(
596		result, NULL, element_qname);
597	0	goto exit;
598		}
599		}
600
601	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
602		!globus_soap_message_serialize_is_c14n_subset(message_handle))
603		{
604
605	0	result = globus_soap_message_attribute_ns_set(
606		message_handle,
607		element_qname,
608		ds_RetrievalMethodType_qname.Namespace,
609		&options);
610	0	if(result != GLOBUS_SUCCESS)
611		{
612	0	result = GlobusSoapMessageErrorSerializeFailed(
613		result, NULL, element_qname);
614	0	goto exit;
615		}
616		}
617
618	0	if(instance->_Type)
619		{
620
621	0	result = globus_soap_message_attribute_ns_set(
622		message_handle,
623		element_qname,
624		NULL,
625		&options);
626
627	0	if(result != GLOBUS_SUCCESS)
628		{
629	0	xsd_QName               error_qname;
630	0	error_qname.local = prefix;
631	0	error_qname.Namespace = "";
632	0	result = GlobusSoapMessageErrorSerializeFailed(result,
633		NULL,
634		&error_qname);
635	0	goto exit;
636		}
637
638
639		}
640
641	0	if(instance->_URI)
642		{
643
644	0	result = globus_soap_message_attribute_ns_set(
645		message_handle,
646		element_qname,
647		NULL,
648		&options);
649
650	0	if(result != GLOBUS_SUCCESS)
651		{
652	0	xsd_QName               error_qname;
653	0	error_qname.local = prefix;
654	0	error_qname.Namespace = "";
655	0	result = GlobusSoapMessageErrorSerializeFailed(result,
656		NULL,
657		&error_qname);
658	0	goto exit;
659		}
660
661
662		}
663
664	0	result = globus_soap_message_serialize_element(
665		message_handle,
666		element_qname,
667		options,
668		&ds_RetrievalMethodType_qname);
669	0	if(result != GLOBUS_SUCCESS)
670		{
671	0	result = GlobusSoapMessageErrorSerializeFailed(
672		result, NULL, element_qname);
673	0	goto exit;
674		}
675
676	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
677		!globus_soap_message_serialize_is_c14n_subset(message_handle))
678		{
679	0	xsd_QName_init(&type_attr);
680
681	0	type_attr->local = globus_libc_strdup("type");
682	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
683		}
684
685
686		/* serialize namespaces */
687	0	result = globus_soap_message_element_ns_add(
688		message_handle,
689		element_qname,
690		element_qname->Namespace,
691		&options);
692	0	if(result != GLOBUS_SUCCESS)
693		{
694	0	result = GlobusSoapMessageErrorSerializeFailed(
695		result, NULL, element_qname);
696	0	goto exit;
697		}
698
699	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
700		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
701		{
702	0	result = globus_soap_message_attribute_ns_add(
703		message_handle,
704		element_qname,
705		"http://www.w3.org/2001/XMLSchema-instance",
706		&options);
707	0	if(result != GLOBUS_SUCCESS)
708		{
709	0	result = GlobusSoapMessageErrorSerializeFailed(
710		result, NULL, element_qname);
711	0	goto exit;
712		}
713		}
714	0	if ((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
715		!globus_soap_message_serialize_is_c14n_subset(message_handle))
716		{
717
718	0	result = globus_soap_message_attribute_ns_add(
719		message_handle,
720		element_qname,
721		ds_RetrievalMethodType_qname.Namespace,
722		&options);
723	0	if(result != GLOBUS_SUCCESS)
724		{
725	0	result = GlobusSoapMessageErrorSerializeFailed(
726		result, NULL, element_qname);
727	0	goto exit;
728		}
729		}
730
731	0	if(instance->_Type)
732		{
733
734	0	result = globus_soap_message_attribute_ns_add(
735		message_handle,
736		element_qname,
737		NULL,
738		&options);
739
740	0	if(result != GLOBUS_SUCCESS)
741		{
742	0	xsd_QName               error_qname;
743	0	error_qname.local = prefix;
744	0	error_qname.Namespace = "";
745	0	result = GlobusSoapMessageErrorSerializeFailed(result,
746		NULL,
747		&error_qname);
748	0	goto exit;
749		}
750
751
752		}
753
754	0	if(instance->_URI)
755		{
756
757	0	result = globus_soap_message_attribute_ns_add(
758		message_handle,
759		element_qname,
760		NULL,
761		&options);
762
763	0	if(result != GLOBUS_SUCCESS)
764		{
765	0	xsd_QName               error_qname;
766	0	error_qname.local = prefix;
767	0	error_qname.Namespace = "";
768	0	result = GlobusSoapMessageErrorSerializeFailed(result,
769		NULL,
770		&error_qname);
771	0	goto exit;
772		}
773
774
775		}
776
777		/* serialize attributes */
778
779	0	subelement.Namespace = "";
780	0	subelement.local = "Type";
781
782	0	if(instance->_Type)
783		{
784
785	0	result = xsd_anyURI_serialize_attribute(
786		&subelement,
787		instance->_Type,
788		message_handle,
789		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
790	0	if(result != GLOBUS_SUCCESS)
791		{
792	0	result = GlobusSoapMessageErrorSerializeFailed(result,
793		NULL,
794		element_qname);
795	0	goto exit;
796		}
797
798		}
799
800	0	subelement.Namespace = "";
801	0	subelement.local = "URI";
802
803	0	if(instance->_URI)
804		{
805
806	0	result = xsd_anyURI_serialize_attribute(
807		&subelement,
808		instance->_URI,
809		message_handle,
810		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
811	0	if(result != GLOBUS_SUCCESS)
812		{
813	0	result = GlobusSoapMessageErrorSerializeFailed(result,
814		NULL,
815		element_qname);
816	0	goto exit;
817		}
818
819		}
820
821	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
822		!globus_soap_message_serialize_is_c14n_subset(message_handle))
823		{
824	0	result = globus_soap_message_serialize_QName_attribute(
825		message_handle,
826		type_attr,
827		&ds_RetrievalMethodType_qname);
828	0	if(result != GLOBUS_SUCCESS)
829		{
830	0	result = GlobusSoapMessageErrorSerializeFailed(
831		result, NULL, element_qname);
832	0	goto exit;
833		}
834		}
835
836
837		}
838
839	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
840		{
841	0	result = globus_soap_message_serialize_element_begin_close(
842		message_handle, element_qname);
843	0	if(result != GLOBUS_SUCCESS)
844		{
845	0	result = GlobusSoapMessageErrorSerializeFailed(
846		result, NULL, element_qname);
847	0	goto exit;
848		}
849		}
850	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
851
852
853		/* serialize contents of type */
854
855	0	subelement.local = "Transforms";
856	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
857
858	0	if(instance->Transforms)
859		{
860	0	result = ds_TransformsType_serialize(
861		&subelement,
862		instance->Transforms,
863		message_handle,
864		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
865	0	if(result != GLOBUS_SUCCESS)
866		{
867	0	result = GlobusSoapMessageErrorSerializeFailed(
868		result, NULL, &ds_TransformsType_qname);
869	0	goto exit;
870		}
871		}
872
873	0	options = save_options;
874
875	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
876		{
877		/* add end element */
878	0	result = globus_soap_message_serialize_element_end(
879		message_handle,
880		element_qname,
881		options,
882		&ds_RetrievalMethodType_qname);
883	0	if(result != GLOBUS_SUCCESS)
884		{
885	0	result = GlobusSoapMessageErrorSerializeFailed(
886		result, NULL, element_qname);
887	0	goto exit;
888		}
889
890	0	globus_soap_message_element_ns_remove(
891		message_handle,
892		element_qname->Namespace,
893		&options);
894
895		/* remove namespace/prefix mappings for these types */
896
897	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
898		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
899		{
900	0	globus_soap_message_attribute_ns_remove(
901		message_handle,
902		"http://www.w3.org/2001/XMLSchema-instance",
903		&options);
904		}
905	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
906		!globus_soap_message_serialize_is_c14n_subset(message_handle))
907		{
908	0	globus_soap_message_attribute_ns_remove(
909		message_handle,
910		ds_RetrievalMethodType_qname.Namespace,
911		&options);
912		}
913
914	0	if(instance->_Type)
915		{
916
917	0	globus_soap_message_attribute_ns_remove(
918		message_handle,
919		NULL,
920		&options);
921
922		}
923
924	0	if(instance->_URI)
925		{
926
927	0	globus_soap_message_attribute_ns_remove(
928		message_handle,
929		NULL,
930		&options);
931
932		}
933
934		}
935
936		exit:
937	0	if (type_attr)
938		{
939	0	xsd_QName_destroy(type_attr);
940		}
941
942
943	0	if(any_attr_keys)
944		{
945	0	globus_list_free(any_attr_keys);
946		}
947
948	0	GlobusSoapMessageDebugExit();
949	0	return result;
950		}
951
952
953
954		globus_result_t
955		ds_RetrievalMethodType_deserialize_contents(
956		const xsd_QName *                   element_qname, /* ignored */
957		ds_RetrievalMethodType *                    inst,
958		globus_soap_message_handle_t        message_handle,
959		globus_xsd_element_options_t        options)
960	0	{
961	0	globus_result_t                     result = GLOBUS_SUCCESS;
962	0	GlobusFuncName(ds_RetrievalMethodType_deserialize_contents);
963	0	GlobusSoapMessageDebugEnter();
964
965	0	result = ds_RetrievalMethodType_deserialize(
966		NULL,
967		inst,
968		message_handle,
969		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
970	0	if(result != GLOBUS_SUCCESS)
971		{
972	0	result = GlobusSoapMessageErrorDeserializeFailed(
973		result, element_qname);
974		goto exit;
975		}
976
977		exit:
978
979	0	GlobusSoapMessageDebugExit();
980	0	return result;
981		}
982
983
984
985		globus_result_t
986		ds_RetrievalMethodType_deserialize(
987		const xsd_QName *                   element_qname,
988		ds_RetrievalMethodType *                    instance,
989		globus_soap_message_handle_t        message_handle,
990		globus_xsd_element_options_t        options)
991	0	{
992	0	globus_result_t                     result = GLOBUS_SUCCESS;
993	0	xsd_QName                           subelement;
994	0	GlobusFuncName(ds_RetrievalMethodType_deserialize);
995	0	GlobusSoapMessageDebugEnter();
996
997
998	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
999		{
1000	0	result = globus_soap_message_deserialize_element(
1001		message_handle, element_qname);
1002	0	if(result != GLOBUS_SUCCESS)
1003		{
1004	0	result = GlobusSoapMessageErrorDeserializeFailed(
1005		result, element_qname);
1006	0	goto exit;
1007		}
1008
1009	0	subelement.Namespace = "";
1010	0	subelement.local = "Type";
1011
1012	0	result = xsd_anyURI_deserialize_attribute_pointer(
1013		&subelement,
1014		&instance->_Type,
1015		message_handle,
1016		0);
1017	0	if(result != GLOBUS_SUCCESS)
1018		{
1019	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1020	0	goto _Type_destroy;
1021		}
1022
1023
1024	0	subelement.Namespace = "";
1025	0	subelement.local = "URI";
1026
1027	0	result = xsd_anyURI_deserialize_attribute_pointer(
1028		&subelement,
1029		&instance->_URI,
1030		message_handle,
1031		0);
1032	0	if(result != GLOBUS_SUCCESS)
1033		{
1034	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1035	0	goto _URI_destroy;
1036		}
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 = "Transforms";
1051	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1052
1053	0	result = ds_TransformsType_deserialize_pointer(
1054		&subelement,
1055		&instance->Transforms,
1056		message_handle,
1057		0);
1058	0	if(result != GLOBUS_SUCCESS)
1059		{
1060	0	result = GlobusSoapMessageErrorDeserializeFailed(
1061		result,
1062		(&subelement));
1063	0	goto Transforms_destroy_pointer;
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		_URI_destroy:
1084		/* output_fail_destroy_attribute() */
1085
1086	0	if(instance->_URI)
1087		{
1088	0	xsd_anyURI_destroy(
1089		instance->_URI);
1090	0	instance->_URI = NULL;
1091		}
1092
1093		_Type_destroy:
1094		/* output_fail_destroy_attribute() */
1095
1096	0	if(instance->_Type)
1097		{
1098	0	xsd_anyURI_destroy(
1099		instance->_Type);
1100	0	instance->_Type = NULL;
1101		}
1102	0	ds_TransformsType_destroy(
1103		instance->Transforms);
1104	0	instance->Transforms = NULL;
1105
1106		Transforms_destroy_pointer:
1107
1108
1109		exit:
1110
1111	0	GlobusSoapMessageDebugExit();
1112	0	return result;
1113		}
1114
1115
1116
1117		globus_result_t
1118		ds_RetrievalMethodType_deserialize_pointer(
1119		const xsd_QName *                   element_qname,
1120		ds_RetrievalMethodType **                   ip,
1121		globus_soap_message_handle_t        message_handle,
1122		globus_xsd_element_options_t        options)
1123	0	{
1124	0	ds_RetrievalMethodType * instance = NULL;
1125	0	globus_result_t                     result = GLOBUS_SUCCESS;
1126	0	xsd_QName                           subelement;
1127	0	int                                 found_attrs = 0;
1128	0	int                                 empty_element = 0;
1129	0	GlobusFuncName(ds_RetrievalMethodType_deserialize_pointer);
1130	0	GlobusSoapMessageDebugEnter();
1131
1132	0	*ip = NULL;
1133
1134	0	result = globus_soap_message_deserialize_element(
1135		message_handle, element_qname);
1136	0	if(result != GLOBUS_SUCCESS &&
1137		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1138		GlobusSoapMessageStatusFailedElementCheck(result) ||
1139		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1140		{
1141	0	result = GLOBUS_SUCCESS;
1142	0	goto exit;
1143		}
1144
1145	0	if(result != GLOBUS_SUCCESS)
1146		{
1147	0	result = GlobusSoapMessageErrorDeserializeFailed(
1148		result, element_qname);
1149	0	goto exit;
1150		}
1151
1152	0	if(globus_soap_message_deserialize_element_is_empty(
1153		message_handle))
1154		{
1155	0	empty_element = 1;
1156		}
1157
1158	0	result = ds_RetrievalMethodType_init(&instance);
1159	0	if(result != GLOBUS_SUCCESS)
1160		{
1161	0	result = GlobusSoapMessageErrorDeserializeFailed(
1162		result, element_qname);
1163	0	goto exit;
1164		}
1165
1166
1167	0	subelement.Namespace = "";
1168	0	subelement.local = "Type";
1169
1170	0	result = xsd_anyURI_deserialize_attribute_pointer(
1171		&subelement,
1172		&instance->_Type,
1173		message_handle,
1174		0);
1175	0	if(result != GLOBUS_SUCCESS)
1176		{
1177	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1178	0	goto _Type_destroy;
1179		}
1180
1181
1182	0	if(instance->_Type)
1183		{
1184	0	found_attrs++;
1185		}
1186
1187	0	subelement.Namespace = "";
1188	0	subelement.local = "URI";
1189
1190	0	result = xsd_anyURI_deserialize_attribute_pointer(
1191		&subelement,
1192		&instance->_URI,
1193		message_handle,
1194		0);
1195	0	if(result != GLOBUS_SUCCESS)
1196		{
1197	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1198	0	goto _URI_destroy;
1199		}
1200
1201
1202	0	if(instance->_URI)
1203		{
1204	0	found_attrs++;
1205		}
1206
1207	0	if(found_attrs == 0 &&
1208		globus_soap_message_deserialize_element_is_nil(message_handle))
1209		{
1210	0	ds_RetrievalMethodType_destroy(instance);
1211
1212	0	result = globus_soap_message_deserialize_element_end(
1213		message_handle,
1214		element_qname);
1215	0	if(result != GLOBUS_SUCCESS)
1216		{
1217	0	result = GlobusSoapMessageErrorDeserializeFailed(
1218		result, element_qname);
1219	0	goto exit;
1220		}
1221
1222	0	*ip = NULL;
1223	0	globus_object_free(globus_error_get(result));
1224	0	result = GLOBUS_SUCCESS;
1225	0	goto exit;
1226		}
1227
1228
1229	0	if(empty_element)
1230		{
1231	0	result = globus_soap_message_deserialize_element_end(
1232		message_handle,
1233		element_qname);
1234	0	if(result != GLOBUS_SUCCESS)
1235		{
1236	0	result = GlobusSoapMessageErrorDeserializeFailed(
1237		result, element_qname);
1238	0	goto fail_deserialize;
1239		}
1240
1241	0	*ip = instance;
1242	0	goto exit;
1243		}
1244
1245	0	result = globus_soap_message_deserialize_element_begin_close(
1246		message_handle);
1247	0	if(result != GLOBUS_SUCCESS)
1248		{
1249	0	result = GlobusSoapMessageErrorDeserializeFailed(
1250		result, element_qname);
1251	0	goto exit;
1252		}
1253
1254	0	result = ds_RetrievalMethodType_deserialize(
1255		element_qname,
1256		instance,
1257		message_handle,
1258		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1259
1260	0	result = globus_soap_message_deserialize_element_end(
1261		message_handle,
1262		element_qname);
1263	0	if(result != GLOBUS_SUCCESS)
1264		{
1265	0	result = GlobusSoapMessageErrorDeserializeFailed(
1266		result, element_qname);
1267	0	goto fail_deserialize;
1268		}
1269
1270	0	*ip = instance;
1271
1272	0	goto exit;
1273
1274		fail_deserialize:
1275
1276		_URI_destroy:
1277		/* output_fail_destroy_attribute() */
1278
1279	0	if(instance->_URI)
1280		{
1281	0	xsd_anyURI_destroy(
1282		instance->_URI);
1283	0	instance->_URI = NULL;
1284		}
1285
1286		_Type_destroy:
1287		/* output_fail_destroy_attribute() */
1288
1289	0	if(instance->_Type)
1290		{
1291	0	xsd_anyURI_destroy(
1292		instance->_Type);
1293	0	instance->_Type = NULL;
1294		}
1295	0	ds_TransformsType_destroy(
1296		instance->Transforms);
1297	0	instance->Transforms = NULL;
1298
1299		Transforms_destroy_pointer:
1300
1301		exit:
1302
1303	0	GlobusSoapMessageDebugExit();
1304	0	return result;
1305		}
1306
1307
1308		globus_result_t
1309		ds_RetrievalMethodType_array_init_contents(
1310		ds_RetrievalMethodType_array * array)
1311	0	{
1312	0	return globus_xsd_generic_array_init_contents(
1313		(globus_xsd_generic_array_t *) array,
1314		&ds_RetrievalMethodType_info);
1315		}
1316		/* ds_RetrievalMethodType_array_init_contents() */
1317
1318		globus_result_t
1319		ds_RetrievalMethodType_array_init(
1320		ds_RetrievalMethodType_array ** arr)
1321	0	{
1322	0	return globus_xsd_generic_array_init(
1323		(globus_xsd_generic_array_t **) arr,
1324		&ds_RetrievalMethodType_info);
1325		}
1326		/* ds_RetrievalMethodType_array_init() */
1327
1328		void
1329		ds_RetrievalMethodType_array_destroy_contents(
1330		ds_RetrievalMethodType_array * array)
1331	0	{
1332	0	globus_xsd_generic_array_destroy_contents(
1333		(globus_xsd_generic_array_t *) array);
1334		}
1335		/* ds_RetrievalMethodType_array_destroy_contents() */
1336
1337		void
1338		ds_RetrievalMethodType_array_destroy(
1339		ds_RetrievalMethodType_array * array)
1340	0	{
1341	0	globus_xsd_generic_array_destroy(
1342		(globus_xsd_generic_array_t *) array);
1343		}
1344		/* ds_RetrievalMethodType_array_destroy() */
1345
1346		globus_result_t
1347		ds_RetrievalMethodType_array_copy(
1348		ds_RetrievalMethodType_array ** dest_arr,
1349		const ds_RetrievalMethodType_array * src_arr)
1350	0	{
1351	0	return globus_xsd_generic_array_copy(
1352		(globus_xsd_generic_array_t **) dest_arr,
1353		(globus_xsd_generic_array_t *) src_arr);
1354		}
1355		/* ds_RetrievalMethodType_array_copy() */
1356
1357		globus_result_t
1358		ds_RetrievalMethodType_array_copy_contents(
1359		ds_RetrievalMethodType_array * dest_arr,
1360		const ds_RetrievalMethodType_array * src_arr)
1361	0	{
1362	0	return globus_xsd_generic_array_copy_contents(
1363		(globus_xsd_generic_array_t *) dest_arr,
1364		(globus_xsd_generic_array_t *) src_arr);
1365		}
1366		/* ds_RetrievalMethodType_array_copy_contents() */
1367
1368		ds_RetrievalMethodType *
1369		ds_RetrievalMethodType_array_push(
1370		ds_RetrievalMethodType_array * array)
1371	0	{
1372		/* Some contents initializers don't initialize subelments but to set their
1373		* values to be NULL
1374		*/
1375	0	if (array->type_info == NULL)
1376		{
1377	0	array->type_info = &ds_RetrievalMethodType_info;
1378		}
1379
1380	0	return globus_xsd_generic_array_push(
1381		(globus_xsd_generic_array_t *) array);
1382		}
1383		/* ds_RetrievalMethodType_array_push() */
1384
1385		void *
1386		ds_RetrievalMethodType_array_push_wrapper(
1387		void * array)
1388	0	{
1389	0	return (void *) ds_RetrievalMethodType_array_push((ds_RetrievalMethodType_array *) array);
1390		}
1391
1392		globus_result_t
1393		ds_RetrievalMethodType_array_serialize(
1394		const xsd_QName *                   element_qname,
1395		const ds_RetrievalMethodType_array *        array,
1396		globus_soap_message_handle_t        message,
1397		globus_xsd_element_options_t        options)
1398	0	{
1399	0	return globus_xsd_generic_array_serialize(
1400		element_qname,
1401		(const globus_xsd_generic_array_t *) array,
1402		message,
1403		options);
1404		}
1405		/* ds_RetrievalMethodType_array_serialize() */
1406
1407		globus_result_t
1408		ds_RetrievalMethodType_array_deserialize(
1409		const xsd_QName *                   element_qname,
1410		ds_RetrievalMethodType_array * array,
1411		globus_soap_message_handle_t        message,
1412		globus_xsd_element_options_t        options)
1413	0	{
1414		/* Some initializers set the array's contents to NULL */
1415	0	if (array->type_info == NULL)
1416		{
1417	0	array->type_info = &ds_RetrievalMethodType_info;
1418		}
1419	0	return globus_xsd_generic_array_deserialize(
1420		element_qname,
1421		(globus_xsd_generic_array_t *) array,
1422		message,
1423		options);