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_RequestedTokenReferenceType.h"
21
22		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
23		xsd_QName wst_RequestedTokenReferenceType_qname =
24		{
25		WST_REQUESTEDTOKENREFERENCETYPE_NS,
26		WST_REQUESTEDTOKENREFERENCETYPE_LOCAL
27		};
28		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
29
30		globus_result_t
31		wst_RequestedTokenReferenceType_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_RequestedTokenReferenceType_serialize(
38		element_qname,
39		(wst_RequestedTokenReferenceType *) instance,
40		message_handle, options);
41		}
42
43		globus_result_t
44		wst_RequestedTokenReferenceType_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_RequestedTokenReferenceType_deserialize_pointer(
51		element_qname,
52		(wst_RequestedTokenReferenceType **) ip,
53		message_handle, options);
54		}
55
56		globus_result_t
57		wst_RequestedTokenReferenceType_init_wrapper(void **object)
58	0	{
59	0	return wst_RequestedTokenReferenceType_init(
60		(wst_RequestedTokenReferenceType **) object);
61		}
62
63		void
64		wst_RequestedTokenReferenceType_destroy_wrapper(
65		void *                          object)
66	0	{
67	0	wst_RequestedTokenReferenceType_destroy(
68		(wst_RequestedTokenReferenceType *) object);
69		}
70
71		globus_result_t
72		wst_RequestedTokenReferenceType_copy_wrapper(
73		void **                         dest_obj,
74		void *                          src_obj)
75	0	{
76	0	return wst_RequestedTokenReferenceType_copy(
77		(wst_RequestedTokenReferenceType **) dest_obj,
78		(wst_RequestedTokenReferenceType *) src_obj);
79		}
80
81		globus_result_t
82		wst_RequestedTokenReferenceType_init_contents_wrapper(void *object)
83	0	{
84	0	return wst_RequestedTokenReferenceType_init_contents(
85		(wst_RequestedTokenReferenceType *) object);
86		}
87
88		void
89		wst_RequestedTokenReferenceType_destroy_contents_wrapper(
90		void *                          object)
91	0	{
92	0	wst_RequestedTokenReferenceType_destroy_contents(
93		(wst_RequestedTokenReferenceType *) object);
94		}
95
96		globus_result_t
97		wst_RequestedTokenReferenceType_copy_contents_wrapper(
98		void *                          dest_obj,
99		void *                          src_obj)
100	0	{
101	0	return wst_RequestedTokenReferenceType_copy_contents(
102		(wst_RequestedTokenReferenceType *) dest_obj,
103		(wst_RequestedTokenReferenceType *) src_obj);
104		}
105
106		globus_result_t
107		wst_RequestedTokenReferenceType_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_RequestedTokenReferenceType_serialize_contents(
114		element_qname,
115		(wst_RequestedTokenReferenceType *) instance,
116		message_handle, options);
117		}
118
119		globus_result_t
120		wst_RequestedTokenReferenceType_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_RequestedTokenReferenceType_deserialize_contents_wrapper);
128	0	GlobusSoapMessageDebugEnter();
129
130	0	if(!*instance)
131		{
132	0	result = wst_RequestedTokenReferenceType_init(
133		(wst_RequestedTokenReferenceType **)instance);
134	0	if(result != GLOBUS_SUCCESS)
135		{
136	0	goto error;
137		}
138		}
139
140	0	result = wst_RequestedTokenReferenceType_deserialize_contents(
141		element_qname,
142		*(wst_RequestedTokenReferenceType **)instance,
143		message_handle, options);
144		error:
145	0	GlobusSoapMessageDebugExit();
146	0	return result;
147		}
148
149		globus_result_t
150		wst_RequestedTokenReferenceType_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_RequestedTokenReferenceType_array_serialize(
157		element,
158		(wst_RequestedTokenReferenceType_array *) instance,
159		message, options);
160		}
161
162		globus_result_t
163		wst_RequestedTokenReferenceType_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_RequestedTokenReferenceType_array_init(
174		(wst_RequestedTokenReferenceType_array **)inst);
175	0	if(result != GLOBUS_SUCCESS)
176		{
177	0	return result;
178		}
179		}
180
181	0	return wst_RequestedTokenReferenceType_array_deserialize(
182		element_qname,
183		*(wst_RequestedTokenReferenceType_array **) inst,
184		message, options);
185		}
186
187		globus_result_t
188		wst_RequestedTokenReferenceType_array_init_wrapper(
189		void **                             arr)
190	0	{
191	0	return wst_RequestedTokenReferenceType_array_init(
192		(wst_RequestedTokenReferenceType_array **) arr);
193		}
194
195		void
196		wst_RequestedTokenReferenceType_array_destroy_wrapper(
197		void *                              arr)
198	0	{
199	0	wst_RequestedTokenReferenceType_array_destroy(
200		(wst_RequestedTokenReferenceType_array *) arr);
201		}
202
203		globus_result_t
204		wst_RequestedTokenReferenceType_array_copy_wrapper(
205		void **                             dest_arr,
206		void *                              src_arr)
207	0	{
208	0	return wst_RequestedTokenReferenceType_array_copy(
209		(wst_RequestedTokenReferenceType_array **) dest_arr,
210		(wst_RequestedTokenReferenceType_array *) src_arr);
211		}
212
213		globus_result_t
214		wst_RequestedTokenReferenceType_array_init_contents_wrapper(
215		void *                              arr)
216	0	{
217	0	return wst_RequestedTokenReferenceType_array_init_contents(
218		(wst_RequestedTokenReferenceType_array *) arr);
219		}
220
221		void
222		wst_RequestedTokenReferenceType_array_destroy_contents_wrapper(
223		void *                              arr)
224	0	{
225	0	wst_RequestedTokenReferenceType_array_destroy_contents(
226		(wst_RequestedTokenReferenceType_array *) arr);
227		}
228
229		globus_result_t
230		wst_RequestedTokenReferenceType_array_copy_contents_wrapper(
231		void *                              dest_arr,
232		void *                              src_arr)
233	0	{
234	0	return wst_RequestedTokenReferenceType_array_copy_contents(
235		(wst_RequestedTokenReferenceType_array *) dest_arr,
236		(wst_RequestedTokenReferenceType_array *) src_arr);
237		}
238
239		struct globus_xsd_type_info_s wst_RequestedTokenReferenceType_contents_info =
240		{
241		&wst_RequestedTokenReferenceType_qname,
242		wst_RequestedTokenReferenceType_serialize_contents_wrapper,
243		wst_RequestedTokenReferenceType_deserialize_contents_wrapper,
244		wst_RequestedTokenReferenceType_init_wrapper,
245		wst_RequestedTokenReferenceType_destroy_wrapper,
246		wst_RequestedTokenReferenceType_copy_wrapper,
247		wst_RequestedTokenReferenceType_init_contents_wrapper,
248		wst_RequestedTokenReferenceType_destroy_contents_wrapper,
249		wst_RequestedTokenReferenceType_copy_contents_wrapper,
250		sizeof(wst_RequestedTokenReferenceType),
251		NULL,
252		NULL,
253		NULL
254		};
255
256		struct globus_xsd_type_info_s wst_RequestedTokenReferenceType_array_info =
257		{
258		&wst_RequestedTokenReferenceType_qname,
259		wst_RequestedTokenReferenceType_array_serialize_wrapper,
260		wst_RequestedTokenReferenceType_array_deserialize_wrapper,
261		wst_RequestedTokenReferenceType_array_init_wrapper,
262		wst_RequestedTokenReferenceType_array_destroy_wrapper,
263		wst_RequestedTokenReferenceType_array_copy_wrapper,
264		wst_RequestedTokenReferenceType_array_init_contents_wrapper,
265		wst_RequestedTokenReferenceType_array_destroy_contents_wrapper,
266		wst_RequestedTokenReferenceType_array_copy_contents_wrapper,
267		sizeof(wst_RequestedTokenReferenceType),
268		wst_RequestedTokenReferenceType_array_push_wrapper,
269		NULL,
270		NULL
271		};
272
273		struct globus_xsd_type_info_s wst_RequestedTokenReferenceType_info =
274		{
275		&wst_RequestedTokenReferenceType_qname,
276		wst_RequestedTokenReferenceType_serialize_wrapper,
277		wst_RequestedTokenReferenceType_deserialize_pointer_wrapper,
278		wst_RequestedTokenReferenceType_init_wrapper,
279		wst_RequestedTokenReferenceType_destroy_wrapper,
280		wst_RequestedTokenReferenceType_copy_wrapper,
281		wst_RequestedTokenReferenceType_init_contents_wrapper,
282		wst_RequestedTokenReferenceType_destroy_contents_wrapper,
283		wst_RequestedTokenReferenceType_copy_contents_wrapper,
284		sizeof(wst_RequestedTokenReferenceType),
285		NULL,
286		&wst_RequestedTokenReferenceType_contents_info,
287		&wst_RequestedTokenReferenceType_array_info
288		};
289
290		globus_result_t
291		wst_RequestedTokenReferenceType_init_contents(
292		wst_RequestedTokenReferenceType * instance)
293	0	{
294	0	globus_result_t                     result = GLOBUS_SUCCESS;
295	0	GlobusFuncName(wst_RequestedTokenReferenceType_init_contents);
296	0	GlobusSoapMessageDebugEnter();
297
298	0	memset(instance, 0, sizeof(wst_RequestedTokenReferenceType));
299
300	0	GlobusSoapMessageDebugExit();
301	0	return result;
302		}
303
304		globus_result_t
305		wst_RequestedTokenReferenceType_init(
306		wst_RequestedTokenReferenceType ** object)
307	0	{
308	0	wst_RequestedTokenReferenceType * instance;
309	0	globus_result_t                     result = GLOBUS_SUCCESS;
310	0	GlobusFuncName(wst_RequestedTokenReferenceType_init);
311	0	GlobusSoapMessageDebugEnter();
312
313	0	instance = globus_malloc(sizeof(wst_RequestedTokenReferenceType));
314	0	if(!instance)
315		{
316	0	result = GlobusSoapMessageErrorOutOfMemory;
317	0	goto exit;
318		}
319
320	0	memset(instance, 0, sizeof(wst_RequestedTokenReferenceType));
321
322	0	*object = instance;
323
324		exit:
325	0	GlobusSoapMessageDebugExit();
326	0	return result;
327		}
328
329		void
330		wst_RequestedTokenReferenceType_destroy(
331		wst_RequestedTokenReferenceType * instance)
332	0	{
333	0	GlobusFuncName(wst_RequestedTokenReferenceType_destroy);
334	0	GlobusSoapMessageDebugEnter();
335
336	0	if(!instance)
337		{
338	0	goto exit;
339		}
340
341	0	wst_RequestedTokenReferenceType_destroy_contents(instance);
342	0	globus_free(instance);
343
344		exit:
345
346	0	GlobusSoapMessageDebugExit();
347		}
348
349		void
350		wst_RequestedTokenReferenceType_destroy_contents(
351		wst_RequestedTokenReferenceType * instance)
352	0	{
353	0	GlobusFuncName(wst_RequestedTokenReferenceType_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	if(instance)
357		{
358
359
360	0	wsse_SecurityTokenReferenceType_destroy_contents(
361		&instance->SecurityTokenReference);
362
363		}
364
365	0	GlobusSoapMessageDebugExit();
366		}
367
368		globus_result_t
369		wst_RequestedTokenReferenceType_copy(
370		wst_RequestedTokenReferenceType ** dest_obj,
371		const wst_RequestedTokenReferenceType * src_obj)
372	0	{
373	0	globus_result_t                     result = GLOBUS_SUCCESS;
374	0	wst_RequestedTokenReferenceType * instance;
375	0	GlobusFuncName(wst_RequestedTokenReferenceType_copy);
376
377	0	GlobusSoapMessageDebugEnter();
378
379	0	instance = malloc(sizeof(wst_RequestedTokenReferenceType));
380	0	if (instance == NULL)
381		{
382	0	GlobusSoapMessageDebugExit();
383	0	return GlobusSoapMessageErrorOutOfMemory;
384		}
385
386	0	result = wst_RequestedTokenReferenceType_copy_contents(instance, src_obj);
387	0	if(result != GLOBUS_SUCCESS)
388		{
389	0	globus_free(instance);
390	0	GlobusSoapMessageDebugExit();
391	0	return GlobusSoapMessageErrorOutOfMemory;
392		}
393
394	0	*dest_obj = instance;
395	0	GlobusSoapMessageDebugExit();
396	0	return result;
397		}
398
399		globus_result_t
400		wst_RequestedTokenReferenceType_copy_contents(
401		wst_RequestedTokenReferenceType * instance,
402		const wst_RequestedTokenReferenceType * src_obj)
403	0	{
404	0	globus_result_t                     result = GLOBUS_SUCCESS;
405	0	GlobusFuncName(wst_RequestedTokenReferenceType_copy_contents);
406
407	0	GlobusSoapMessageDebugEnter();
408
409
410	0	result = wsse_SecurityTokenReferenceType_copy_contents(
411		&instance->SecurityTokenReference,
412		&src_obj->SecurityTokenReference);
413	0	if(result != GLOBUS_SUCCESS)
414		{
415	0	result = GlobusSoapMessageErrorCopyFailed(
416		result, NULL, &wsse_SecurityTokenReferenceType_qname);
417		goto SecurityTokenReference_destroy;
418		}
419
420	0	goto exit;
421
422		fail_deserialize:
423	0	wsse_SecurityTokenReferenceType_destroy_contents(
424		&instance->SecurityTokenReference);
425
426		SecurityTokenReference_destroy:
427
428
429		exit:
430
431	0	GlobusSoapMessageDebugExit();
432	0	return result;
433		}
434
435
436
437		globus_result_t
438		wst_RequestedTokenReferenceType_serialize_contents(
439		xsd_QName *                         element_qname, /* ignored */
440		wst_RequestedTokenReferenceType * inst,
441		globus_soap_message_handle_t        message_handle,
442		globus_xsd_element_options_t        options)
443	0	{
444	0	globus_result_t                     result = GLOBUS_SUCCESS;
445	0	GlobusFuncName(wst_RequestedTokenReferenceType_serialize_contents);
446	0	GlobusSoapMessageDebugEnter();
447
448	0	result = wst_RequestedTokenReferenceType_serialize(
449		NULL,
450		inst,
451		message_handle,
452		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
453	0	if(result != GLOBUS_SUCCESS)
454		{
455	0	result = GlobusSoapMessageErrorSerializeFailed(
456		result, NULL, element_qname);
457		goto exit;
458		}
459
460		exit:
461
462	0	GlobusSoapMessageDebugExit();
463	0	return result;
464		}
465
466
467
468		globus_result_t
469		wst_RequestedTokenReferenceType_serialize(
470		xsd_QName *                         element_qname,
471		wst_RequestedTokenReferenceType * instance,
472		globus_soap_message_handle_t        message_handle,
473		globus_xsd_element_options_t        options)
474	0	{
475	0	globus_result_t                     result = GLOBUS_SUCCESS;
476	0	xsd_QName                           subelement;
477	0	globus_list_t *                     any_attr_keys = NULL;
478	0	globus_list_t *                     any_attr_keys_iterator = NULL;
479	0	xsd_QName *                         type_attr = NULL;
480	0	char *                              prefix = NULL;
481	0	int                                 prefix_created;
482	0	int                                 define_prefix = 0;
483	0	int                                 save_options = options;
484
485	0	GlobusFuncName(wst_RequestedTokenReferenceType_serialize);
486	0	GlobusSoapMessageDebugEnter();
487
488
489	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
490		{
491		/* serialize wst_RequestedTokenReferenceType element */
492
493	0	result = globus_soap_message_invoke_ns_callouts(
494		message_handle,
495		element_qname,
496		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_SET,
497		&options);
498	0	if(result != GLOBUS_SUCCESS)
499		{
500	0	result = GlobusSoapMessageErrorSerializeFailed(
501		result, NULL, element_qname);
502	0	goto exit;
503		}
504
505	0	result = globus_soap_message_element_ns_set(
506		message_handle,
507		element_qname->Namespace,
508		&options);
509	0	if(result != GLOBUS_SUCCESS)
510		{
511	0	result = GlobusSoapMessageErrorSerializeFailed(
512		result, NULL, element_qname);
513	0	goto exit;
514		}
515
516	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
517		!globus_soap_message_serialize_is_c14n_subset(message_handle))
518		{
519	0	result = globus_soap_message_attribute_ns_set(
520		message_handle,
521		"http://www.w3.org/2001/XMLSchema-instance",
522		&options);
523	0	if(result != GLOBUS_SUCCESS)
524		{
525	0	result = GlobusSoapMessageErrorSerializeFailed(
526		result, NULL, element_qname);
527	0	goto exit;
528		}
529
530	0	result = globus_soap_message_attribute_ns_set(
531		message_handle,
532		wst_RequestedTokenReferenceType_qname.Namespace,
533		&options);
534	0	if(result != GLOBUS_SUCCESS)
535		{
536	0	result = GlobusSoapMessageErrorSerializeFailed(
537		result, NULL, element_qname);
538	0	goto exit;
539		}
540		}
541
542	0	result = globus_soap_message_invoke_callouts(
543		message_handle,
544		element_qname,
545		GLOBUS_SOAP_MESSAGE_CALLOUT_BEGIN);
546	0	if(result != GLOBUS_SUCCESS)
547		{
548	0	result = GlobusSoapMessageErrorSerializeFailed(
549		result, NULL, element_qname);
550	0	goto exit;
551		}
552
553	0	result = globus_soap_message_serialize_element(
554		message_handle,
555		element_qname,
556		options,
557		&wst_RequestedTokenReferenceType_qname);
558	0	if(result != GLOBUS_SUCCESS)
559		{
560	0	result = GlobusSoapMessageErrorSerializeFailed(
561		result, NULL, element_qname);
562	0	goto exit;
563		}
564
565	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
566		!globus_soap_message_serialize_is_c14n_subset(message_handle))
567		{
568	0	xsd_QName_init(&type_attr);
569
570	0	type_attr->local = globus_libc_strdup("type");
571	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
572		}
573
574		/* serialize namespaces */
575
576	0	result = globus_soap_message_invoke_ns_callouts(
577		message_handle,
578		element_qname,
579		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_ADD,
580		&options);
581	0	if(result != GLOBUS_SUCCESS)
582		{
583	0	result = GlobusSoapMessageErrorSerializeFailed(
584		result, NULL, element_qname);
585	0	goto exit;
586		}
587
588	0	result = globus_soap_message_element_ns_add(
589		message_handle,
590		element_qname->Namespace,
591		&options);
592	0	if(result != GLOBUS_SUCCESS)
593		{
594	0	result = GlobusSoapMessageErrorSerializeFailed(
595		result, NULL, element_qname);
596	0	goto exit;
597		}
598
599	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
600		!globus_soap_message_serialize_is_c14n_subset(message_handle))
601		{
602	0	result = globus_soap_message_attribute_ns_add(
603		message_handle,
604		"http://www.w3.org/2001/XMLSchema-instance",
605		&options);
606	0	if(result != GLOBUS_SUCCESS)
607		{
608	0	result = GlobusSoapMessageErrorSerializeFailed(
609		result, NULL, element_qname);
610	0	goto exit;
611		}
612
613	0	result = globus_soap_message_attribute_ns_add(
614		message_handle,
615		wst_RequestedTokenReferenceType_qname.Namespace,
616		&options);
617	0	if(result != GLOBUS_SUCCESS)
618		{
619	0	result = GlobusSoapMessageErrorSerializeFailed(
620		result, NULL, element_qname);
621	0	goto exit;
622		}
623		}
624
625		/* serialize attributes */
626
627	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
628		!globus_soap_message_serialize_is_c14n_subset(message_handle))
629		{
630	0	result = globus_soap_message_serialize_QName_attribute(
631		message_handle,
632		type_attr,
633		&wst_RequestedTokenReferenceType_qname);
634	0	if(result != GLOBUS_SUCCESS)
635		{
636	0	result = GlobusSoapMessageErrorSerializeFailed(
637		result, NULL, element_qname);
638	0	goto exit;
639		}
640		}
641
642
643	0	result = globus_soap_message_invoke_callouts(
644		message_handle,
645		element_qname,
646		GLOBUS_SOAP_MESSAGE_CALLOUT_ATTR);
647	0	if(result != GLOBUS_SUCCESS)
648		{
649	0	result = GlobusSoapMessageErrorSerializeFailed(
650		result, NULL, element_qname);
651	0	goto exit;
652		}
653		}
654
655	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
656		{
657	0	result = globus_soap_message_serialize_element_begin_close(
658		message_handle);
659	0	if(result != GLOBUS_SUCCESS)
660		{
661	0	result = GlobusSoapMessageErrorSerializeFailed(
662		result, NULL, element_qname);
663	0	goto exit;
664		}
665		}
666	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
667
668		/* serialize contents of type */
669
670	0	subelement.local = "SecurityTokenReference";
671	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
672
673	0	result = wsse_SecurityTokenReferenceType_serialize(
674		&subelement,
675		&instance->SecurityTokenReference,
676		message_handle,
677		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
678	0	if(result != GLOBUS_SUCCESS)
679		{
680	0	result = GlobusSoapMessageErrorSerializeFailed(
681		result, NULL, &wsse_SecurityTokenReferenceType_qname);
682	0	goto exit;
683		}
684
685	0	options = save_options;
686
687	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
688		{
689		/* add end element */
690	0	result = globus_soap_message_serialize_element_end(
691		message_handle,
692		element_qname,
693		options,
694		&wst_RequestedTokenReferenceType_qname);
695	0	if(result != GLOBUS_SUCCESS)
696		{
697	0	result = GlobusSoapMessageErrorSerializeFailed(
698		result, NULL, element_qname);
699	0	goto exit;
700		}
701
702	0	globus_soap_message_element_ns_remove(
703		message_handle,
704		element_qname->Namespace,
705		&options);
706
707		/* remove namespace/prefix mappings for these types */
708
709	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
710		!globus_soap_message_serialize_is_c14n_subset(message_handle))
711		{
712	0	globus_soap_message_attribute_ns_remove(
713		message_handle,
714		"http://www.w3.org/2001/XMLSchema-instance",
715		&options);
716
717	0	globus_soap_message_attribute_ns_remove(
718		message_handle,
719		wst_RequestedTokenReferenceType_qname.Namespace,
720		&options);
721		}
722
723	0	result = globus_soap_message_invoke_ns_callouts(
724		message_handle,
725		element_qname,
726		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_REMOVE,
727		&options);
728	0	if(result != GLOBUS_SUCCESS)
729		{
730	0	result  = GlobusSoapMessageErrorSerializeFailed(
731		result, NULL, element_qname);
732	0	goto exit;
733		}
734
735	0	result = globus_soap_message_invoke_callouts(
736		message_handle,
737		element_qname,
738		GLOBUS_SOAP_MESSAGE_CALLOUT_END);
739	0	if(result != GLOBUS_SUCCESS)
740		{
741	0	result = GlobusSoapMessageErrorSerializeFailed(
742		result, NULL, element_qname);
743		goto exit;
744		}
745		}
746
747		exit:
748	0	if (type_attr)
749		{
750	0	xsd_QName_destroy(type_attr);
751		}
752
753	0	if(any_attr_keys)
754		{
755	0	globus_list_free(any_attr_keys);
756		}
757
758	0	GlobusSoapMessageDebugExit();
759	0	return result;
760		}
761
762
763
764		globus_result_t
765		wst_RequestedTokenReferenceType_deserialize_contents(
766		xsd_QName *                         element_qname, /* ignored */
767		wst_RequestedTokenReferenceType * inst,
768		globus_soap_message_handle_t        message_handle,
769		globus_xsd_element_options_t        options)
770	0	{
771	0	globus_result_t                     result = GLOBUS_SUCCESS;
772	0	GlobusFuncName(wst_RequestedTokenReferenceType_deserialize_contents);
773	0	GlobusSoapMessageDebugEnter();
774
775	0	result = wst_RequestedTokenReferenceType_deserialize(
776		NULL,
777		inst,
778		message_handle,
779		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
780	0	if(result != GLOBUS_SUCCESS)
781		{
782	0	result = GlobusSoapMessageErrorDeserializeFailed(
783		result, element_qname);
784		goto exit;
785		}
786
787		exit:
788
789	0	GlobusSoapMessageDebugExit();
790	0	return result;
791		}
792
793
794
795		globus_result_t
796		wst_RequestedTokenReferenceType_deserialize(
797		xsd_QName *                         element_qname,
798		wst_RequestedTokenReferenceType * instance,
799		globus_soap_message_handle_t        message_handle,
800		globus_xsd_element_options_t        options)
801	0	{
802	0	globus_result_t                     result = GLOBUS_SUCCESS;
803	0	xsd_QName                           subelement;
804	0	GlobusFuncName(wst_RequestedTokenReferenceType_deserialize);
805	0	GlobusSoapMessageDebugEnter();
806
807
808	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
809		{
810	0	result = globus_soap_message_deserialize_element(
811		message_handle, element_qname);
812	0	if(result != GLOBUS_SUCCESS)
813		{
814	0	result = GlobusSoapMessageErrorDeserializeFailed(
815		result, element_qname);
816	0	goto exit;
817		}
818
819
820	0	result = globus_soap_message_deserialize_element_begin_close(
821		message_handle);
822	0	if(result != GLOBUS_SUCCESS)
823		{
824	0	result = GlobusSoapMessageErrorDeserializeFailed(
825		result, element_qname);
826	0	goto fail_deserialize;
827		}
828		}
829
830	0	subelement.local = "SecurityTokenReference";
831	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
832
833	0	result = wsse_SecurityTokenReferenceType_deserialize(
834		&subelement,
835		&instance->SecurityTokenReference,
836		message_handle,
837		0);
838	0	if(result != GLOBUS_SUCCESS)
839		{
840	0	result = GlobusSoapMessageErrorDeserializeFailed(
841		result,
842		&wsse_SecurityTokenReferenceType_qname);
843	0	goto SecurityTokenReference_destroy;
844		}
845
846	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
847		{
848	0	result = globus_soap_message_deserialize_element_end(
849		message_handle,
850		element_qname);
851	0	if(result != GLOBUS_SUCCESS)
852		{
853	0	result = GlobusSoapMessageErrorDeserializeFailed(
854		result, element_qname);
855		goto fail_deserialize;
856		}
857		}
858
859	0	goto exit;
860
861		fail_deserialize:
862	0	wsse_SecurityTokenReferenceType_destroy_contents(
863		&instance->SecurityTokenReference);
864
865		SecurityTokenReference_destroy:
866
867
868		exit:
869
870	0	GlobusSoapMessageDebugExit();
871	0	return result;
872		}
873
874
875
876		globus_result_t
877		wst_RequestedTokenReferenceType_deserialize_pointer(
878		xsd_QName *                         element_qname,
879		wst_RequestedTokenReferenceType ** ip,
880		globus_soap_message_handle_t        message_handle,
881		globus_xsd_element_options_t        options)
882	0	{
883	0	wst_RequestedTokenReferenceType * instance = NULL;
884	0	globus_result_t                     result = GLOBUS_SUCCESS;
885	0	xsd_QName                           subelement;
886	0	int                                 found_attrs = 0;
887	0	int                                 empty_element = 0;
888	0	GlobusFuncName(wst_RequestedTokenReferenceType_deserialize_pointer);
889	0	GlobusSoapMessageDebugEnter();
890
891	0	*ip = NULL;
892
893	0	result = globus_soap_message_deserialize_element(
894		message_handle, element_qname);
895	0	if(result != GLOBUS_SUCCESS &&
896		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
897		GlobusSoapMessageStatusFailedElementCheck(result) ||
898		GlobusSoapMessageStatusFailedWithTextCheck(result)))
899		{
900	0	*ip = NULL;
901	0	result = GLOBUS_SUCCESS;
902	0	goto exit;
903		}
904
905	0	if(result != GLOBUS_SUCCESS)
906		{
907	0	result = GlobusSoapMessageErrorDeserializeFailed(
908		result, element_qname);
909	0	goto exit;
910		}
911
912	0	if(globus_soap_message_deserialize_element_is_empty(
913		message_handle))
914		{
915	0	empty_element = 1;
916		}
917
918
919
920	0	result = wst_RequestedTokenReferenceType_init(&instance);
921	0	if(result != GLOBUS_SUCCESS)
922		{
923	0	result = GlobusSoapMessageErrorDeserializeFailed(
924		result, element_qname);
925	0	goto exit;
926		}
927
928
929	0	if(found_attrs == 0 &&
930		globus_soap_message_deserialize_element_is_nil(message_handle))
931		{
932	0	wst_RequestedTokenReferenceType_destroy(instance);
933
934	0	result = globus_soap_message_deserialize_element_end(
935		message_handle,
936		element_qname);
937	0	if(result != GLOBUS_SUCCESS)
938		{
939	0	result = GlobusSoapMessageErrorDeserializeFailed(
940		result, element_qname);
941	0	goto exit;
942		}
943
944	0	*ip = NULL;
945	0	globus_object_free(globus_error_get(result));
946	0	result = GLOBUS_SUCCESS;
947	0	goto exit;
948		}
949
950
951	0	if(empty_element)
952		{
953	0	result = globus_soap_message_deserialize_element_end(
954		message_handle,
955		element_qname);
956	0	if(result != GLOBUS_SUCCESS)
957		{
958	0	result = GlobusSoapMessageErrorDeserializeFailed(
959		result, element_qname);
960	0	goto fail_deserialize;
961		}
962
963	0	*ip = instance;
964	0	goto exit;
965		}
966
967	0	result = globus_soap_message_deserialize_element_begin_close(
968		message_handle);
969	0	if(result != GLOBUS_SUCCESS)
970		{
971	0	result = GlobusSoapMessageErrorDeserializeFailed(
972		result, element_qname);
973	0	goto exit;
974		}
975
976
977	0	subelement.local = "SecurityTokenReference";
978	0	subelement.Namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd";
979
980	0	result = wsse_SecurityTokenReferenceType_deserialize(
981		&subelement,
982		&instance->SecurityTokenReference,
983		message_handle,
984		0);
985	0	if(result != GLOBUS_SUCCESS)
986		{
987	0	result = GlobusSoapMessageErrorDeserializeFailed(
988		result,
989		&wsse_SecurityTokenReferenceType_qname);
990	0	goto SecurityTokenReference_destroy;
991		}
992
993
994	0	result = globus_soap_message_deserialize_element_end(
995		message_handle,
996		element_qname);
997	0	if(result != GLOBUS_SUCCESS)
998		{
999	0	result = GlobusSoapMessageErrorDeserializeFailed(
1000		result, element_qname);
1001	0	goto fail_deserialize;
1002		}
1003
1004	0	*ip = instance;
1005
1006	0	goto exit;
1007
1008		fail_deserialize:
1009	0	wsse_SecurityTokenReferenceType_destroy_contents(
1010		&instance->SecurityTokenReference);
1011
1012		SecurityTokenReference_destroy:
1013
1014		exit:
1015
1016	0	GlobusSoapMessageDebugExit();
1017	0	return result;
1018		}
1019
1020
1021		globus_result_t
1022		wst_RequestedTokenReferenceType_array_init_contents(
1023		wst_RequestedTokenReferenceType_array * array)
1024	0	{
1025	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_init_contents);
1026	0	GlobusSoapMessageDebugEnter();
1027
1028	0	memset(array, 0, sizeof(wst_RequestedTokenReferenceType_array));
1029
1030	0	GlobusSoapMessageDebugExit();
1031	0	return GLOBUS_SUCCESS;
1032		}
1033
1034		globus_result_t
1035		wst_RequestedTokenReferenceType_array_init(
1036		wst_RequestedTokenReferenceType_array ** arr)
1037	0	{
1038	0	wst_RequestedTokenReferenceType_array * array;
1039	0	globus_result_t                     result;
1040	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_init);
1041	0	GlobusSoapMessageDebugEnter();
1042
1043	0	array = (wst_RequestedTokenReferenceType_array *)
1044		globus_malloc(sizeof(wst_RequestedTokenReferenceType_array));
1045	0	if(!array)
1046		{
1047	0	result = GlobusSoapMessageErrorOutOfMemory;
1048	0	goto exit;
1049		}
1050
1051	0	result = wst_RequestedTokenReferenceType_array_init_contents(array);
1052	0	if(result != GLOBUS_SUCCESS)
1053		{
1054	0	globus_free(array);
1055	0	array = NULL;
1056
1057		}
1058
1059	0	*arr = array;
1060
1061		exit:
1062	0	GlobusSoapMessageDebugExit();
1063	0	return result;
1064		}
1065
1066		void
1067		wst_RequestedTokenReferenceType_array_destroy_contents(
1068		wst_RequestedTokenReferenceType_array * array)
1069	0	{
1070	0	int                                 i = 0;
1071	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_destroy_contents);
1072	0	GlobusSoapMessageDebugEnter();
1073
1074	0	for(; i < array->length; ++i)
1075		{
1076	0	wst_RequestedTokenReferenceType_destroy_contents(&array->elements[i]);
1077		}
1078
1079	0	if(array->elements)
1080		{
1081	0	globus_free(array->elements);
1082	0	array->elements = NULL;
1083		}
1084	0	array->length = 0;
1085
1086	0	GlobusSoapMessageDebugExit();
1087		}
1088
1089		void
1090		wst_RequestedTokenReferenceType_array_destroy(
1091		wst_RequestedTokenReferenceType_array * array)
1092	0	{
1093	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_destroy);
1094	0	GlobusSoapMessageDebugEnter();
1095
1096	0	wst_RequestedTokenReferenceType_array_destroy_contents(array);
1097	0	globus_free(array);
1098
1099	0	GlobusSoapMessageDebugExit();
1100		}
1101
1102		globus_result_t
1103		wst_RequestedTokenReferenceType_array_copy(
1104		wst_RequestedTokenReferenceType_array ** dest_arr,
1105		const wst_RequestedTokenReferenceType_array * src_arr)
1106	0	{
1107	0	wst_RequestedTokenReferenceType_array * array;
1108	0	globus_result_t                     result;
1109	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_copy);
1110	0	GlobusSoapMessageDebugEnter();
1111
1112	0	array = (wst_RequestedTokenReferenceType_array *) globus_malloc(
1113		sizeof(wst_RequestedTokenReferenceType_array));
1114	0	if(!array)
1115		{
1116	0	result = GlobusSoapMessageErrorOutOfMemory;
1117	0	GlobusSoapMessageDebugExit();
1118	0	return result;
1119		}
1120
1121	0	result = wst_RequestedTokenReferenceType_array_copy_contents(array, src_arr);
1122	0	if(result != GLOBUS_SUCCESS)
1123		{
1124	0	globus_free(array);
1125	0	GlobusSoapMessageDebugExit();
1126	0	return result;
1127		}
1128
1129	0	*dest_arr = array;
1130
1131	0	GlobusSoapMessageDebugExit();
1132	0	return GLOBUS_SUCCESS;
1133		}
1134
1135		globus_result_t
1136		wst_RequestedTokenReferenceType_array_copy_contents(
1137		wst_RequestedTokenReferenceType_array * dest_arr,
1138		const wst_RequestedTokenReferenceType_array * src_arr)
1139	0	{
1140	0	int                                 i;
1141	0	globus_result_t                     result = GLOBUS_SUCCESS;
1142	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_copy_contents);
1143	0	GlobusSoapMessageDebugEnter();
1144
1145	0	dest_arr->length = src_arr->length;
1146	0	if(dest_arr->length > 0)
1147		{
1148	0	dest_arr->elements = (wst_RequestedTokenReferenceType *) malloc(
1149		sizeof(wst_RequestedTokenReferenceType) * dest_arr->length);
1150	0	if(!dest_arr->elements)
1151		{
1152	0	result = GlobusSoapMessageErrorOutOfMemory;
1153	0	GlobusSoapMessageDebugExit();
1154	0	return result;
1155		}
1156		}
1157		else
1158		{
1159	0	dest_arr->elements = NULL;
1160		}
1161
1162	0	for(i = 0; i < dest_arr->length; i++)
1163		{
1164	0	result = wst_RequestedTokenReferenceType_copy_contents(
1165		&dest_arr->elements[i], &src_arr->elements[i]);
1166	0	if(result != GLOBUS_SUCCESS)
1167		{
1168	0	while(i--)
1169		{
1170	0	wst_RequestedTokenReferenceType_destroy_contents(&dest_arr->elements[i]);
1171		}
1172
1173	0	globus_free(dest_arr->elements);
1174	0	dest_arr->elements = NULL;
1175	0	dest_arr->length = 0;
1176	0	break;
1177		}
1178		}
1179
1180	0	GlobusSoapMessageDebugExit();
1181	0	return result;
1182		}
1183
1184		wst_RequestedTokenReferenceType *
1185		wst_RequestedTokenReferenceType_array_push(
1186		wst_RequestedTokenReferenceType_array * array)
1187	0	{
1188	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_push);
1189	0	GlobusSoapMessageDebugEnter();
1190
1191	0	array->elements = realloc(array->elements,
1192		sizeof(wst_RequestedTokenReferenceType) *
1193		(array->length + 1));
1194	0	memset(&array->elements[array->length], 0, sizeof(wst_RequestedTokenReferenceType));
1195	0	array->length++;
1196
1197	0	GlobusSoapMessageDebugExit();
1198	0	return (&array->elements[array->length - 1]);
1199		}
1200
1201		void *
1202		wst_RequestedTokenReferenceType_array_push_wrapper(
1203		void * array)
1204	0	{
1205	0	return (void *) wst_RequestedTokenReferenceType_array_push((wst_RequestedTokenReferenceType_array *) array);
1206		}
1207
1208		globus_result_t
1209		wst_RequestedTokenReferenceType_array_serialize(
1210		xsd_QName *                         element_qname,
1211		wst_RequestedTokenReferenceType_array * array,
1212		globus_soap_message_handle_t        message,
1213		globus_xsd_element_options_t        options)
1214	0	{
1215	0	globus_result_t                     result = GLOBUS_SUCCESS;
1216	0	int                                 i = 0;
1217	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_serialize);
1218	0	GlobusSoapMessageDebugEnter();
1219
1220	0	for(; i < array->length; ++i)
1221		{
1222	0	result = wst_RequestedTokenReferenceType_serialize(
1223		element_qname,
1224		&array->elements[i],
1225		message,
1226		options);
1227	0	if(result != GLOBUS_SUCCESS)
1228		{
1229	0	goto exit;
1230		}
1231		}
1232
1233		exit:
1234
1235	0	GlobusSoapMessageDebugExit();
1236	0	return result;
1237		}
1238
1239		globus_result_t
1240		wst_RequestedTokenReferenceType_array_deserialize(
1241		xsd_QName *                         element_qname,
1242		wst_RequestedTokenReferenceType_array * array,
1243		globus_soap_message_handle_t        message,
1244		globus_xsd_element_options_t        options)
1245	0	{
1246	0	globus_result_t                     result = GLOBUS_SUCCESS;
1247	0	int                                 i = 0;
1248	0	int                                 pre_length;
1249	0	GlobusFuncName(wst_RequestedTokenReferenceType_array_deserialize);
1250	0	GlobusSoapMessageDebugEnter();
1251
1252	0	pre_length = array->length;
1253
1254	0	for(i = 0; i < pre_length; ++i)
1255		{
1256	0	result = wst_RequestedTokenReferenceType_deserialize(
1257		element_qname,
1258		&array->elements[i],
1259		message,
1260		options);
1261	0	if(result != GLOBUS_SUCCESS)
1262		{
1263	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1264		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1265		GlobusSoapMessageStatusFailedWithTextCheck(result))
1266		{
1267	0	result = GLOBUS_SUCCESS;
1268	0	break;
1269		}
1270
1271	0	result = GlobusSoapMessageErrorDeserializeFailed(
1272		result, element_qname);
1273	0	goto exit;
1274		}
1275		}
1276
1277	0	while(result == GLOBUS_SUCCESS)
1278		{
1279	0	wst_RequestedTokenReferenceType                  next;
1280	0	memset(&next, 0, sizeof(wst_RequestedTokenReferenceType));
1281
1282	0	result = wst_RequestedTokenReferenceType_deserialize(
1283		element_qname,
1284		&next,
1285		message,
1286		options);
1287	0	if(result != GLOBUS_SUCCESS)
1288		{
1289	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1290		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1291		GlobusSoapMessageStatusFailedWithTextCheck(result))
1292		{
1293	0	result = GLOBUS_SUCCESS;
1294	0	break;
1295		}
1296
1297	0	result = GlobusSoapMessageErrorDeserializeFailed(
1298		result, element_qname);
1299	0	goto exit;
1300		}
1301
1302	0	array->elements = realloc(
1303		array->elements,
1304		(array->length + 1) * sizeof(wst_RequestedTokenReferenceType));
1305	0	if(!array->elements)
1306		{
1307	0	result = GlobusSoapMessageErrorOutOfMemory;
1308	0	goto exit;
1309		}
1310	0	array->elements[array->length] = next;
1311	0	array->length++;
1312	0	++i;
1313		}
1314
1315		exit:
1316
1317	0	if(result != GLOBUS_SUCCESS)
1318		{
1319	0	int                             di = 0;
1320	0	for(; di < i; ++di)
1321		{
1322	0	wst_RequestedTokenReferenceType_destroy_contents(
1323		&array->elements[di]);
1324	0	memset(&array->elements[di], 0, sizeof(wst_RequestedTokenReferenceType));
1325		}
1326		}
1327
1328	0	GlobusSoapMessageDebugExit();
1329	0	return result;