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