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