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