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