1		/*
2		* Copyright 1999-2006 University of Chicago
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17
18		/*
19		* This file is automatically generated by the Globus WSDLtoC converter
20		*/
21
22		#include "xsd_QName.h"
23		#include "globus_soap_message.h"
24		#include "globus_xsd_type_info.h"
25		#include "wst_KeyExchangeTokenType.h"
26
27		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
28		xsd_QName wst_KeyExchangeTokenType_qname =
29		{
30		WST_KEYEXCHANGETOKENTYPE_NS,
31		WST_KEYEXCHANGETOKENTYPE_LOCAL
32		};
33		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
34
35		globus_result_t
36		wst_KeyExchangeTokenType_serialize_wrapper(
37		const xsd_QName *                   element_qname,
38		const void *                        instance,
39		globus_soap_message_handle_t        message_handle,
40		globus_xsd_element_options_t        options)
41	0	{
42	0	return wst_KeyExchangeTokenType_serialize(
43		element_qname,
44		(const wst_KeyExchangeTokenType *) instance,
45		message_handle, options);
46		}
47
48		globus_result_t
49		wst_KeyExchangeTokenType_deserialize_pointer_wrapper(
50		const xsd_QName *                   element_qname,
51		void **                             ip,
52		globus_soap_message_handle_t        message_handle,
53		globus_xsd_element_options_t        options)
54	0	{
55	0	return wst_KeyExchangeTokenType_deserialize_pointer(
56		element_qname,
57		(wst_KeyExchangeTokenType **) ip,
58		message_handle, options);
59		}
60
61		globus_result_t
62		wst_KeyExchangeTokenType_init_wrapper(void **object)
63	0	{
64	0	return wst_KeyExchangeTokenType_init(
65		(wst_KeyExchangeTokenType **) object);
66		}
67
68		void
69		wst_KeyExchangeTokenType_destroy_wrapper(
70		void *                          object)
71	0	{
72	0	wst_KeyExchangeTokenType_destroy(
73		(wst_KeyExchangeTokenType *) object);
74		}
75
76		globus_result_t
77		wst_KeyExchangeTokenType_copy_wrapper(
78		void **                         dest_obj,
79		const void *                    src_obj)
80	0	{
81	0	return wst_KeyExchangeTokenType_copy(
82		(wst_KeyExchangeTokenType **) dest_obj,
83		(wst_KeyExchangeTokenType *) src_obj);
84		}
85
86		globus_result_t
87		wst_KeyExchangeTokenType_init_contents_wrapper(void *object)
88	0	{
89	0	return wst_KeyExchangeTokenType_init_contents(
90		(wst_KeyExchangeTokenType *) object);
91		}
92
93		void
94		wst_KeyExchangeTokenType_destroy_contents_wrapper(
95		void *                          object)
96	0	{
97	0	wst_KeyExchangeTokenType_destroy_contents(
98		(wst_KeyExchangeTokenType *) object);
99		}
100
101		globus_result_t
102		wst_KeyExchangeTokenType_copy_contents_wrapper(
103		void *                          dest_obj,
104		const void *                    src_obj)
105	0	{
106	0	return wst_KeyExchangeTokenType_copy_contents(
107		(wst_KeyExchangeTokenType *) dest_obj,
108		(const wst_KeyExchangeTokenType *) src_obj);
109		}
110
111		globus_result_t
112		wst_KeyExchangeTokenType_serialize_contents_wrapper(
113		const xsd_QName *                   element_qname,
114		const void *                        instance,
115		globus_soap_message_handle_t        message_handle,
116		globus_xsd_element_options_t        options)
117	0	{
118	0	return wst_KeyExchangeTokenType_serialize_contents(
119		element_qname,
120		(wst_KeyExchangeTokenType *) instance,
121		message_handle, options);
122		}
123
124		globus_result_t
125		wst_KeyExchangeTokenType_deserialize_contents_wrapper(
126		const xsd_QName *                   element_qname,
127		void **                             instance,
128		globus_soap_message_handle_t        message_handle,
129		globus_xsd_element_options_t        options)
130	0	{
131	0	globus_result_t                     result;
132	0	GlobusFuncName(wst_KeyExchangeTokenType_deserialize_contents_wrapper);
133	0	GlobusSoapMessageDebugEnter();
134
135	0	if(!*instance)
136		{
137	0	result = wst_KeyExchangeTokenType_init(
138		(wst_KeyExchangeTokenType **)instance);
139	0	if(result != GLOBUS_SUCCESS)
140		{
141	0	goto error;
142		}
143		}
144
145	0	result = wst_KeyExchangeTokenType_deserialize_contents(
146		element_qname,
147		*(wst_KeyExchangeTokenType **)instance,
148		message_handle, options);
149		error:
150	0	GlobusSoapMessageDebugExit();
151	0	return result;
152		}
153
154		globus_result_t
155		wst_KeyExchangeTokenType_array_serialize_wrapper(
156		const xsd_QName *               element,
157		const void *                    instance,
158		globus_soap_message_handle_t    message,
159		globus_xsd_element_options_t    options)
160	0	{
161	0	return wst_KeyExchangeTokenType_array_serialize(
162		element,
163		(wst_KeyExchangeTokenType_array *) instance,
164		message, options);
165		}
166
167		globus_result_t
168		wst_KeyExchangeTokenType_array_deserialize_wrapper(
169		const xsd_QName *                   element_qname,
170		void **                             inst,
171		globus_soap_message_handle_t        message,
172		globus_xsd_element_options_t        options)
173	0	{
174	0	if(!*inst)
175		{
176	0	globus_result_t                 result;
177
178	0	result = wst_KeyExchangeTokenType_array_init(
179		(wst_KeyExchangeTokenType_array **)inst);
180	0	if(result != GLOBUS_SUCCESS)
181		{
182	0	return result;
183		}
184		}
185
186	0	return wst_KeyExchangeTokenType_array_deserialize(
187		element_qname,
188		*(wst_KeyExchangeTokenType_array **) inst,
189		message, options);
190		}
191
192		globus_result_t
193		wst_KeyExchangeTokenType_array_init_wrapper(
194		void **                             arr)
195	0	{
196	0	return wst_KeyExchangeTokenType_array_init(
197		(wst_KeyExchangeTokenType_array **) arr);
198		}
199
200		void
201		wst_KeyExchangeTokenType_array_destroy_wrapper(
202		void *                              arr)
203	0	{
204	0	wst_KeyExchangeTokenType_array_destroy(
205		(wst_KeyExchangeTokenType_array *) arr);
206		}
207
208		globus_result_t
209		wst_KeyExchangeTokenType_array_copy_wrapper(
210		void **                             dest_arr,
211		const void *                        src_arr)
212	0	{
213	0	return wst_KeyExchangeTokenType_array_copy(
214		(wst_KeyExchangeTokenType_array **) dest_arr,
215		(const wst_KeyExchangeTokenType_array *) src_arr);
216		}
217
218		globus_result_t
219		wst_KeyExchangeTokenType_array_init_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	return wst_KeyExchangeTokenType_array_init_contents(
223		(wst_KeyExchangeTokenType_array *) arr);
224		}
225
226		void
227		wst_KeyExchangeTokenType_array_destroy_contents_wrapper(
228		void *                              arr)
229	0	{
230	0	wst_KeyExchangeTokenType_array_destroy_contents(
231		(wst_KeyExchangeTokenType_array *) arr);
232		}
233
234		globus_result_t
235		wst_KeyExchangeTokenType_array_copy_contents_wrapper(
236		void *                              dest_arr,
237		const void *                        src_arr)
238	0	{
239	0	return wst_KeyExchangeTokenType_array_copy_contents(
240		(wst_KeyExchangeTokenType_array *) dest_arr,
241		(const wst_KeyExchangeTokenType_array *) src_arr);
242		}
243
244		struct globus_xsd_type_info_s wst_KeyExchangeTokenType_contents_info =
245		{
246		&wst_KeyExchangeTokenType_qname,
247		wst_KeyExchangeTokenType_serialize_contents_wrapper,
248		wst_KeyExchangeTokenType_deserialize_contents_wrapper,
249		wst_KeyExchangeTokenType_init_wrapper,
250		wst_KeyExchangeTokenType_destroy_wrapper,
251		wst_KeyExchangeTokenType_copy_wrapper,
252		wst_KeyExchangeTokenType_init_contents_wrapper,
253		wst_KeyExchangeTokenType_destroy_contents_wrapper,
254		wst_KeyExchangeTokenType_copy_contents_wrapper,
255		sizeof(wst_KeyExchangeTokenType),
256		NULL,
257		NULL,
258		NULL
259		};
260
261		struct globus_xsd_type_info_s wst_KeyExchangeTokenType_array_info =
262		{
263		&wst_KeyExchangeTokenType_qname,
264		wst_KeyExchangeTokenType_array_serialize_wrapper,
265		wst_KeyExchangeTokenType_array_deserialize_wrapper,
266		wst_KeyExchangeTokenType_array_init_wrapper,
267		wst_KeyExchangeTokenType_array_destroy_wrapper,
268		wst_KeyExchangeTokenType_array_copy_wrapper,
269		wst_KeyExchangeTokenType_array_init_contents_wrapper,
270		wst_KeyExchangeTokenType_array_destroy_contents_wrapper,
271		wst_KeyExchangeTokenType_array_copy_contents_wrapper,
272		sizeof(wst_KeyExchangeTokenType),
273		wst_KeyExchangeTokenType_array_push_wrapper,
274		NULL,
275		NULL
276		};
277
278		struct globus_xsd_type_info_s wst_KeyExchangeTokenType_info =
279		{
280		&wst_KeyExchangeTokenType_qname,
281		wst_KeyExchangeTokenType_serialize_wrapper,
282		wst_KeyExchangeTokenType_deserialize_pointer_wrapper,
283		wst_KeyExchangeTokenType_init_wrapper,
284		wst_KeyExchangeTokenType_destroy_wrapper,
285		wst_KeyExchangeTokenType_copy_wrapper,
286		wst_KeyExchangeTokenType_init_contents_wrapper,
287		wst_KeyExchangeTokenType_destroy_contents_wrapper,
288		wst_KeyExchangeTokenType_copy_contents_wrapper,
289		sizeof(wst_KeyExchangeTokenType),
290		NULL,
291		&wst_KeyExchangeTokenType_contents_info,
292		&wst_KeyExchangeTokenType_array_info
293		};
294
295		globus_result_t
296		wst_KeyExchangeTokenType_init_contents(
297		wst_KeyExchangeTokenType * instance)
298	0	{
299	0	globus_result_t                     result = GLOBUS_SUCCESS;
300	0	GlobusFuncName(wst_KeyExchangeTokenType_init_contents);
301	0	GlobusSoapMessageDebugEnter();
302
303	0	memset(instance, 0, sizeof(wst_KeyExchangeTokenType));
304
305	0	GlobusSoapMessageDebugExit();
306	0	return result;
307		}
308
309		globus_result_t
310		wst_KeyExchangeTokenType_init(
311		wst_KeyExchangeTokenType ** object)
312	0	{
313	0	wst_KeyExchangeTokenType * instance;
314	0	globus_result_t                     result = GLOBUS_SUCCESS;
315	0	GlobusFuncName(wst_KeyExchangeTokenType_init);
316	0	GlobusSoapMessageDebugEnter();
317
318	0	instance = globus_malloc(sizeof(wst_KeyExchangeTokenType));
319	0	if(!instance)
320		{
321	0	result = GlobusSoapMessageErrorOutOfMemory;
322	0	goto exit;
323		}
324
325	0	memset(instance, 0, sizeof(wst_KeyExchangeTokenType));
326
327	0	*object = instance;
328
329		exit:
330	0	GlobusSoapMessageDebugExit();
331	0	return result;
332		}
333
334		void
335		wst_KeyExchangeTokenType_destroy(
336		wst_KeyExchangeTokenType * instance)
337	0	{
338	0	GlobusFuncName(wst_KeyExchangeTokenType_destroy);
339	0	GlobusSoapMessageDebugEnter();
340
341	0	if(!instance)
342		{
343	0	goto exit;
344		}
345
346	0	wst_KeyExchangeTokenType_destroy_contents(instance);
347	0	globus_free(instance);
348
349		exit:
350
351	0	GlobusSoapMessageDebugExit();
352		}
353
354
355		void
356		wst_KeyExchangeTokenType_destroy_contents(
357		wst_KeyExchangeTokenType * instance)
358	0	{
359	0	GlobusFuncName(wst_KeyExchangeTokenType_destroy_contents);
360	0	GlobusSoapMessageDebugEnter();
361
362	0	if(instance)
363		{
364
365
366	0	xsd_any_array_destroy_contents(&instance->any);
367
368		}
369
370	0	GlobusSoapMessageDebugExit();
371		}
372
373
374		globus_result_t
375		wst_KeyExchangeTokenType_copy(
376		wst_KeyExchangeTokenType ** dest_obj,
377		const wst_KeyExchangeTokenType * src_obj)
378	0	{
379	0	globus_result_t                     result = GLOBUS_SUCCESS;
380	0	wst_KeyExchangeTokenType * instance;
381	0	GlobusFuncName(wst_KeyExchangeTokenType_copy);
382
383	0	GlobusSoapMessageDebugEnter();
384
385	0	instance = calloc(1, sizeof(wst_KeyExchangeTokenType));
386	0	if (instance == NULL)
387		{
388	0	GlobusSoapMessageDebugExit();
389	0	return GlobusSoapMessageErrorOutOfMemory;
390		}
391
392	0	result = wst_KeyExchangeTokenType_copy_contents(instance, src_obj);
393	0	if(result != GLOBUS_SUCCESS)
394		{
395	0	globus_free(instance);
396	0	GlobusSoapMessageDebugExit();
397	0	return GlobusSoapMessageErrorOutOfMemory;
398		}
399
400	0	*dest_obj = instance;
401	0	GlobusSoapMessageDebugExit();
402	0	return result;
403		}
404
405		globus_result_t
406		wst_KeyExchangeTokenType_copy_contents(
407		wst_KeyExchangeTokenType * instance,
408		const wst_KeyExchangeTokenType * src_obj)
409	0	{
410	0	globus_result_t                     result = GLOBUS_SUCCESS;
411	0	GlobusFuncName(wst_KeyExchangeTokenType_copy_contents);
412
413	0	GlobusSoapMessageDebugEnter();
414
415	0	result = xsd_any_array_copy_contents(
416		&instance->any,
417		&src_obj->any);
418	0	if(result != GLOBUS_SUCCESS)
419		{
420	0	result = GlobusSoapMessageErrorCopyFailed(
421		result, NULL, &xsd_any_qname);
422		goto any_destroy_array;
423		}
424
425	0	goto exit;
426
427		fail_deserialize:
428	0	xsd_any_array_destroy_contents(
429		&instance->any);
430
431		any_destroy_array:
432
433
434		exit:
435
436	0	GlobusSoapMessageDebugExit();
437	0	return result;
438		}
439
440
441
442		globus_result_t
443		wst_KeyExchangeTokenType_serialize_contents(
444		const xsd_QName *                   element_qname, /* ignored */
445		const wst_KeyExchangeTokenType *              inst,
446		globus_soap_message_handle_t        message_handle,
447		globus_xsd_element_options_t        options)
448	0	{
449	0	globus_result_t                     result = GLOBUS_SUCCESS;
450	0	GlobusFuncName(wst_KeyExchangeTokenType_serialize_contents);
451	0	GlobusSoapMessageDebugEnter();
452
453	0	result = wst_KeyExchangeTokenType_serialize(
454		NULL,
455		inst,
456		message_handle,
457		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
458	0	if(result != GLOBUS_SUCCESS)
459		{
460	0	result = GlobusSoapMessageErrorSerializeFailed(
461		result, NULL, element_qname);
462		goto exit;
463		}
464
465		exit:
466
467	0	GlobusSoapMessageDebugExit();
468	0	return result;
469		}
470
471
472
473		globus_result_t
474		wst_KeyExchangeTokenType_serialize(
475		const xsd_QName *                   element_qname,
476		const wst_KeyExchangeTokenType *              instance,
477		globus_soap_message_handle_t        message_handle,
478		globus_xsd_element_options_t        options)
479	0	{
480	0	globus_result_t                     result = GLOBUS_SUCCESS;
481	0	xsd_QName                           subelement;
482	0	globus_list_t *                     any_attr_keys = NULL;
483	0	globus_list_t *                     any_attr_keys_iterator = NULL;
484	0	xsd_QName *                         type_attr = NULL;
485
486	0	char *                              prefix = NULL;
487	0	int                                 prefix_created;
488	0	int                                 define_prefix = 0;
489	0	int                                 save_options = options;
490
491	0	GlobusFuncName(wst_KeyExchangeTokenType_serialize);
492	0	GlobusSoapMessageDebugEnter();
493
494
495	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
496		{
497		/* serialize wst_KeyExchangeTokenType element */
498	0	result = globus_soap_message_element_ns_set(
499		message_handle,
500		element_qname,
501		element_qname->Namespace,
502		&options);
503	0	if(result != GLOBUS_SUCCESS)
504		{
505	0	result = GlobusSoapMessageErrorSerializeFailed(
506		result, NULL, element_qname);
507	0	goto exit;
508		}
509
510		{
511	0	int ani;
512
513	0	for (ani = 0; ani < instance->any.length; ani++)
514
515		{
516		/*
517		int nsi;
518		for (nsi = 0; nsi < instance->any.elements[ani].namespaces.length; nsi++)
519		{
520		if (instance->any.elements[ani].namespaces.elements[nsi] != NULL)
521		{
522		char * prefix;
523		char * ns;
524		prefix = globus_libc_strdup(
525		instance->any.elements[ani].namespaces.elements[nsi]);
526		if (prefix == NULL)
527		{
528		result = GlobusSoapMessageErrorOutOfMemory;
529
530		goto exit;
531		}
532		ns = strchr(prefix, '=');
533		if (ns == NULL)
534		{
535		free(prefix);
536
537		result = GlobusSoapMessageErrorSerializeNamespaceFailed(ns, prefix);
538		goto exit;
539		}
540		*(ns) = '\0';
541		ns++;
542		result = globus_soap_message_serialize_ns_set_prefix(
543		message_handle,
544		element_qname,
545		ns,
546		prefix,
547		&options);
548		free(prefix);
549		if(result != GLOBUS_SUCCESS)
550		{
551		goto exit;
552		}
553		}
554		}
555		*/
556		}
557
558		}
559
560	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
561		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
562		{
563	0	result = globus_soap_message_attribute_ns_set(
564		message_handle,
565		element_qname,
566		"http://www.w3.org/2001/XMLSchema-instance",
567		&options);
568	0	if(result != GLOBUS_SUCCESS)
569		{
570	0	result = GlobusSoapMessageErrorSerializeFailed(
571		result, NULL, element_qname);
572	0	goto exit;
573		}
574		}
575
576	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
577		!globus_soap_message_serialize_is_c14n_subset(message_handle))
578		{
579
580	0	result = globus_soap_message_attribute_ns_set(
581		message_handle,
582		element_qname,
583		wst_KeyExchangeTokenType_qname.Namespace,
584		&options);
585	0	if(result != GLOBUS_SUCCESS)
586		{
587	0	result = GlobusSoapMessageErrorSerializeFailed(
588		result, NULL, element_qname);
589	0	goto exit;
590		}
591		}
592
593	0	result = globus_soap_message_serialize_element(
594		message_handle,
595		element_qname,
596		options,
597		&wst_KeyExchangeTokenType_qname);
598	0	if(result != GLOBUS_SUCCESS)
599		{
600	0	result = GlobusSoapMessageErrorSerializeFailed(
601		result, NULL, element_qname);
602	0	goto exit;
603		}
604
605	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
606		!globus_soap_message_serialize_is_c14n_subset(message_handle))
607		{
608	0	xsd_QName_init(&type_attr);
609
610	0	type_attr->local = globus_libc_strdup("type");
611	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
612		}
613
614
615		/* serialize namespaces */
616	0	result = globus_soap_message_element_ns_add(
617		message_handle,
618		element_qname,
619		element_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	int ani;
630
631	0	for (ani = 0; ani < instance->any.length; ani++)
632
633		{
634		/*
635		int nsi;
636		for (nsi = 0; nsi < instance->any.elements[ani].namespaces.length; nsi++)
637		{
638		if (instance->any.elements[ani].namespaces.elements[nsi] != NULL)
639		{
640		char * prefix;
641		char * ns;
642
643		prefix = globus_libc_strdup(
644		instance->any.elements[ani].namespaces.elements[nsi]);
645		if (prefix == NULL)
646		{
647		result = GlobusSoapMessageErrorOutOfMemory;
648
649		goto exit;
650		}
651		ns = strchr(prefix, '=');
652		if (ns == NULL)
653		{
654		free(prefix);
655
656		result = GlobusSoapMessageErrorSerializeNamespaceFailed(ns, prefix);
657		goto exit;
658		}
659		*(ns) = '\0';
660		ns++;
661		result = globus_soap_message_serialize_ns_add_prefix(
662		message_handle,
663		element_qname,
664		ns,
665		prefix,
666		&options);
667		free(prefix);
668		if(result != GLOBUS_SUCCESS)
669		{
670		goto exit;
671		}
672		}
673		}
674		*/
675		}
676
677		}
678
679	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
680		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
681		{
682	0	result = globus_soap_message_attribute_ns_add(
683		message_handle,
684		element_qname,
685		"http://www.w3.org/2001/XMLSchema-instance",
686		&options);
687	0	if(result != GLOBUS_SUCCESS)
688		{
689	0	result = GlobusSoapMessageErrorSerializeFailed(
690		result, NULL, element_qname);
691	0	goto exit;
692		}
693		}
694	0	if ((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
695		!globus_soap_message_serialize_is_c14n_subset(message_handle))
696		{
697
698	0	result = globus_soap_message_attribute_ns_add(
699		message_handle,
700		element_qname,
701		wst_KeyExchangeTokenType_qname.Namespace,
702		&options);
703	0	if(result != GLOBUS_SUCCESS)
704		{
705	0	result = GlobusSoapMessageErrorSerializeFailed(
706		result, NULL, element_qname);
707	0	goto exit;
708		}
709		}
710
711		/* serialize attributes */
712
713	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
714		!globus_soap_message_serialize_is_c14n_subset(message_handle))
715		{
716	0	result = globus_soap_message_serialize_QName_attribute(
717		message_handle,
718		type_attr,
719		&wst_KeyExchangeTokenType_qname);
720	0	if(result != GLOBUS_SUCCESS)
721		{
722	0	result = GlobusSoapMessageErrorSerializeFailed(
723		result, NULL, element_qname);
724	0	goto exit;
725		}
726		}
727
728
729		}
730
731	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
732		{
733	0	result = globus_soap_message_serialize_element_begin_close(
734		message_handle, element_qname);
735	0	if(result != GLOBUS_SUCCESS)
736		{
737	0	result = GlobusSoapMessageErrorSerializeFailed(
738		result, NULL, element_qname);
739	0	goto exit;
740		}
741		}
742	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
743
744
745		/* serialize contents of type */
746
747	0	subelement.local = "any";
748	0	subelement.Namespace = "http://www.w3.org/2001/XMLSchema";
749
750	0	result = xsd_any_array_serialize(
751		&subelement,
752		&instance->any,
753		message_handle,
754		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
755	0	if(result != GLOBUS_SUCCESS)
756		{
757	0	result = GlobusSoapMessageErrorSerializeFailed(
758		result, NULL, &xsd_any_qname);
759	0	goto exit;
760		}
761
762	0	options = save_options;
763
764	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
765		{
766		/* add end element */
767	0	result = globus_soap_message_serialize_element_end(
768		message_handle,
769		element_qname,
770		options,
771		&wst_KeyExchangeTokenType_qname);
772	0	if(result != GLOBUS_SUCCESS)
773		{
774	0	result = GlobusSoapMessageErrorSerializeFailed(
775		result, NULL, element_qname);
776	0	goto exit;
777		}
778
779	0	globus_soap_message_element_ns_remove(
780		message_handle,
781		element_qname->Namespace,
782		&options);
783
784		/* remove namespace/prefix mappings for these types */
785
786		{
787	0	int ani;
788
789	0	for (ani = 0; ani < instance->any.length; ani++)
790
791		{
792		/*
793		int nsi;
794		for (nsi = 0; nsi < instance->any.elements[ani].namespaces.length; nsi++)
795		{
796		if (instance->any.elements[ani].namespaces.elements[nsi] != NULL)
797		{
798		char * prefix;
799		char * ns;
800
801		prefix = globus_libc_strdup(
802		instance->any.elements[ani].namespaces.elements[nsi]);
803		if (prefix == NULL)
804		{
805		result = GlobusSoapMessageErrorOutOfMemory;
806
807		goto exit;
808		}
809		ns = strchr(prefix, '=');
810		if (ns == NULL)
811		{
812		free(prefix);
813
814		result = GlobusSoapMessageErrorSerializeNamespaceFailed(ns, prefix);
815		goto exit;
816		}
817		*(ns) = '\0';
818		ns++;
819
820		globus_soap_message_serialize_ns_remove_prefix(
821		message_handle,
822		ns,
823		prefix,
824		&options);
825		free(prefix);
826		}
827		}
828		*/
829		}
830
831		}
832
833	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
834		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
835		{
836	0	globus_soap_message_attribute_ns_remove(
837		message_handle,
838		"http://www.w3.org/2001/XMLSchema-instance",
839		&options);
840		}
841	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
842		!globus_soap_message_serialize_is_c14n_subset(message_handle))
843		{
844	0	globus_soap_message_attribute_ns_remove(
845		message_handle,
846		wst_KeyExchangeTokenType_qname.Namespace,
847		&options);
848		}
849
850		}
851
852		exit:
853	0	if (type_attr)
854		{
855	0	xsd_QName_destroy(type_attr);
856		}
857
858
859	0	if(any_attr_keys)
860		{
861	0	globus_list_free(any_attr_keys);
862		}
863
864	0	GlobusSoapMessageDebugExit();
865	0	return result;
866		}
867
868
869
870		globus_result_t
871		wst_KeyExchangeTokenType_deserialize_contents(
872		const xsd_QName *                   element_qname, /* ignored */
873		wst_KeyExchangeTokenType *                    inst,
874		globus_soap_message_handle_t        message_handle,
875		globus_xsd_element_options_t        options)
876	0	{
877	0	globus_result_t                     result = GLOBUS_SUCCESS;
878	0	GlobusFuncName(wst_KeyExchangeTokenType_deserialize_contents);
879	0	GlobusSoapMessageDebugEnter();
880
881	0	result = wst_KeyExchangeTokenType_deserialize(
882		NULL,
883		inst,
884		message_handle,
885		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
886	0	if(result != GLOBUS_SUCCESS)
887		{
888	0	result = GlobusSoapMessageErrorDeserializeFailed(
889		result, element_qname);
890		goto exit;
891		}
892
893		exit:
894
895	0	GlobusSoapMessageDebugExit();
896	0	return result;
897		}
898
899
900
901		globus_result_t
902		wst_KeyExchangeTokenType_deserialize(
903		const xsd_QName *                   element_qname,
904		wst_KeyExchangeTokenType *                    instance,
905		globus_soap_message_handle_t        message_handle,
906		globus_xsd_element_options_t        options)
907	0	{
908	0	globus_result_t                     result = GLOBUS_SUCCESS;
909	0	xsd_QName                           subelement;
910	0	GlobusFuncName(wst_KeyExchangeTokenType_deserialize);
911	0	GlobusSoapMessageDebugEnter();
912
913
914	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
915		{
916	0	result = globus_soap_message_deserialize_element(
917		message_handle, element_qname);
918	0	if(result != GLOBUS_SUCCESS)
919		{
920	0	result = GlobusSoapMessageErrorDeserializeFailed(
921		result, element_qname);
922	0	goto exit;
923		}
924
925
926	0	result = globus_soap_message_deserialize_element_begin_close(
927		message_handle);
928	0	if(result != GLOBUS_SUCCESS)
929		{
930	0	result = GlobusSoapMessageErrorDeserializeFailed(
931		result, element_qname);
932	0	goto fail_deserialize;
933		}
934		}
935
936	0	subelement.local = "any";
937	0	subelement.Namespace = "http://www.w3.org/2001/XMLSchema";
938
939	0	result = xsd_any_array_deserialize(
940		&subelement,
941		&instance->any,
942		message_handle,
943		0);
944	0	if(result != GLOBUS_SUCCESS)
945		{
946	0	result = GlobusSoapMessageErrorDeserializeFailed(
947		result,
948		(&subelement));
949	0	goto any_destroy_array;
950		}
951
952	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
953		{
954	0	result = globus_soap_message_deserialize_element_end(
955		message_handle,
956		element_qname);
957	0	if(result != GLOBUS_SUCCESS)
958		{
959	0	result = GlobusSoapMessageErrorDeserializeFailed(
960		result, element_qname);
961		goto fail_deserialize;
962		}
963		}
964
965	0	goto exit;
966
967		fail_deserialize:
968	0	xsd_any_array_destroy_contents(
969		&instance->any);
970
971		any_destroy_array:
972
973
974		exit:
975
976	0	GlobusSoapMessageDebugExit();
977	0	return result;
978		}
979
980
981
982		globus_result_t
983		wst_KeyExchangeTokenType_deserialize_pointer(
984		const xsd_QName *                   element_qname,
985		wst_KeyExchangeTokenType **                   ip,
986		globus_soap_message_handle_t        message_handle,
987		globus_xsd_element_options_t        options)
988	0	{
989	0	wst_KeyExchangeTokenType * instance = NULL;
990	0	globus_result_t                     result = GLOBUS_SUCCESS;
991	0	xsd_QName                           subelement;
992	0	int                                 found_attrs = 0;
993	0	int                                 empty_element = 0;
994	0	GlobusFuncName(wst_KeyExchangeTokenType_deserialize_pointer);
995	0	GlobusSoapMessageDebugEnter();
996
997	0	*ip = NULL;
998
999	0	result = globus_soap_message_deserialize_element(
1000		message_handle, element_qname);
1001	0	if(result != GLOBUS_SUCCESS &&
1002		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1003		GlobusSoapMessageStatusFailedElementCheck(result) ||
1004		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1005		{
1006	0	result = GLOBUS_SUCCESS;
1007	0	goto exit;
1008		}
1009
1010	0	if(result != GLOBUS_SUCCESS)
1011		{
1012	0	result = GlobusSoapMessageErrorDeserializeFailed(
1013		result, element_qname);
1014	0	goto exit;
1015		}
1016
1017	0	if(globus_soap_message_deserialize_element_is_empty(
1018		message_handle))
1019		{
1020	0	empty_element = 1;
1021		}
1022
1023	0	result = wst_KeyExchangeTokenType_init(&instance);
1024	0	if(result != GLOBUS_SUCCESS)
1025		{
1026	0	result = GlobusSoapMessageErrorDeserializeFailed(
1027		result, element_qname);
1028	0	goto exit;
1029		}
1030
1031
1032	0	if(found_attrs == 0 &&
1033		globus_soap_message_deserialize_element_is_nil(message_handle))
1034		{
1035	0	wst_KeyExchangeTokenType_destroy(instance);
1036
1037	0	result = globus_soap_message_deserialize_element_end(
1038		message_handle,
1039		element_qname);
1040	0	if(result != GLOBUS_SUCCESS)
1041		{
1042	0	result = GlobusSoapMessageErrorDeserializeFailed(
1043		result, element_qname);
1044	0	goto exit;
1045		}
1046
1047	0	*ip = NULL;
1048	0	globus_object_free(globus_error_get(result));
1049	0	result = GLOBUS_SUCCESS;
1050	0	goto exit;
1051		}
1052
1053
1054	0	if(empty_element)
1055		{
1056	0	result = globus_soap_message_deserialize_element_end(
1057		message_handle,
1058		element_qname);
1059	0	if(result != GLOBUS_SUCCESS)
1060		{
1061	0	result = GlobusSoapMessageErrorDeserializeFailed(
1062		result, element_qname);
1063	0	goto fail_deserialize;
1064		}
1065
1066	0	*ip = instance;
1067	0	goto exit;
1068		}
1069
1070	0	result = globus_soap_message_deserialize_element_begin_close(
1071		message_handle);
1072	0	if(result != GLOBUS_SUCCESS)
1073		{
1074	0	result = GlobusSoapMessageErrorDeserializeFailed(
1075		result, element_qname);
1076	0	goto exit;
1077		}
1078
1079	0	result = wst_KeyExchangeTokenType_deserialize(
1080		element_qname,
1081		instance,
1082		message_handle,
1083		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1084
1085	0	result = globus_soap_message_deserialize_element_end(
1086		message_handle,
1087		element_qname);
1088	0	if(result != GLOBUS_SUCCESS)
1089		{
1090	0	result = GlobusSoapMessageErrorDeserializeFailed(
1091		result, element_qname);
1092	0	goto fail_deserialize;
1093		}
1094
1095	0	*ip = instance;
1096
1097	0	goto exit;
1098
1099		fail_deserialize:
1100	0	xsd_any_array_destroy_contents(
1101		&instance->any);
1102
1103		any_destroy_array:
1104
1105		exit:
1106
1107	0	GlobusSoapMessageDebugExit();
1108	0	return result;
1109		}
1110
1111
1112		globus_result_t
1113		wst_KeyExchangeTokenType_array_init_contents(
1114		wst_KeyExchangeTokenType_array * array)
1115	0	{
1116	0	return globus_xsd_generic_array_init_contents(
1117		(globus_xsd_generic_array_t *) array,
1118		&wst_KeyExchangeTokenType_info);
1119		}
1120		/* wst_KeyExchangeTokenType_array_init_contents() */
1121
1122		globus_result_t
1123		wst_KeyExchangeTokenType_array_init(
1124		wst_KeyExchangeTokenType_array ** arr)
1125	0	{
1126	0	return globus_xsd_generic_array_init(
1127		(globus_xsd_generic_array_t **) arr,
1128		&wst_KeyExchangeTokenType_info);
1129		}
1130		/* wst_KeyExchangeTokenType_array_init() */
1131
1132		void
1133		wst_KeyExchangeTokenType_array_destroy_contents(
1134		wst_KeyExchangeTokenType_array * array)
1135	0	{
1136	0	globus_xsd_generic_array_destroy_contents(
1137		(globus_xsd_generic_array_t *) array);
1138		}
1139		/* wst_KeyExchangeTokenType_array_destroy_contents() */
1140
1141		void
1142		wst_KeyExchangeTokenType_array_destroy(
1143		wst_KeyExchangeTokenType_array * array)
1144	0	{
1145	0	globus_xsd_generic_array_destroy(
1146		(globus_xsd_generic_array_t *) array);
1147		}
1148		/* wst_KeyExchangeTokenType_array_destroy() */
1149
1150		globus_result_t
1151		wst_KeyExchangeTokenType_array_copy(
1152		wst_KeyExchangeTokenType_array ** dest_arr,
1153		const wst_KeyExchangeTokenType_array * src_arr)
1154	0	{
1155	0	return globus_xsd_generic_array_copy(
1156		(globus_xsd_generic_array_t **) dest_arr,
1157		(globus_xsd_generic_array_t *) src_arr);
1158		}
1159		/* wst_KeyExchangeTokenType_array_copy() */
1160
1161		globus_result_t
1162		wst_KeyExchangeTokenType_array_copy_contents(
1163		wst_KeyExchangeTokenType_array * dest_arr,
1164		const wst_KeyExchangeTokenType_array * src_arr)
1165	0	{
1166	0	return globus_xsd_generic_array_copy_contents(
1167		(globus_xsd_generic_array_t *) dest_arr,
1168		(globus_xsd_generic_array_t *) src_arr);
1169		}
1170		/* wst_KeyExchangeTokenType_array_copy_contents() */
1171
1172		wst_KeyExchangeTokenType *
1173		wst_KeyExchangeTokenType_array_push(
1174		wst_KeyExchangeTokenType_array * array)
1175	0	{
1176		/* Some contents initializers don't initialize subelments but to set their
1177		* values to be NULL
1178		*/
1179	0	if (array->type_info == NULL)
1180		{
1181	0	array->type_info = &wst_KeyExchangeTokenType_info;
1182		}
1183
1184	0	return globus_xsd_generic_array_push(
1185		(globus_xsd_generic_array_t *) array);
1186		}
1187		/* wst_KeyExchangeTokenType_array_push() */
1188
1189		void *
1190		wst_KeyExchangeTokenType_array_push_wrapper(
1191		void * array)
1192	0	{
1193	0	return (void *) wst_KeyExchangeTokenType_array_push((wst_KeyExchangeTokenType_array *) array);
1194		}
1195
1196		globus_result_t
1197		wst_KeyExchangeTokenType_array_serialize(
1198		const xsd_QName *                   element_qname,
1199		const wst_KeyExchangeTokenType_array *        array,
1200		globus_soap_message_handle_t        message,
1201		globus_xsd_element_options_t        options)
1202	0	{
1203	0	return globus_xsd_generic_array_serialize(
1204		element_qname,
1205		(const globus_xsd_generic_array_t *) array,
1206		message,
1207		options);
1208		}
1209		/* wst_KeyExchangeTokenType_array_serialize() */
1210
1211		globus_result_t
1212		wst_KeyExchangeTokenType_array_deserialize(
1213		const xsd_QName *                   element_qname,
1214		wst_KeyExchangeTokenType_array * array,
1215		globus_soap_message_handle_t        message,
1216		globus_xsd_element_options_t        options)
1217	0	{
1218		/* Some initializers set the array's contents to NULL */
1219	0	if (array->type_info == NULL)
1220		{
1221	0	array->type_info = &wst_KeyExchangeTokenType_info;
1222		}
1223	0	return globus_xsd_generic_array_deserialize(
1224		element_qname,
1225		(globus_xsd_generic_array_t *) array,
1226		message,
1227		options);