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