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