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