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