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_StatusCodeEnum.h"
21
22		xsd_QName wst_StatusCodeEnum_qname =
23		{
24		"http://schemas.xmlsoap.org/ws/2004/04/trust",
25		"StatusCodeEnum"
26		};
27
28		globus_result_t
29		wst_StatusCodeEnum_serialize_wrapper(
30		xsd_QName *                         element_qname,
31		void *                              instance,
32		globus_soap_message_handle_t        message_handle,
33		globus_xsd_element_options_t        options)
34	0	{
35	0	return wst_StatusCodeEnum_serialize(
36		element_qname,
37		(wst_StatusCodeEnum *) instance,
38		message_handle, options);
39		}
40
41		globus_result_t
42		wst_StatusCodeEnum_deserialize_pointer_wrapper(
43		xsd_QName *                         element_qname,
44		void **                             ip,
45		globus_soap_message_handle_t        message_handle,
46		globus_xsd_element_options_t        options)
47	0	{
48	0	return wst_StatusCodeEnum_deserialize_pointer(
49		element_qname,
50		(wst_StatusCodeEnum **) ip,
51		message_handle, options);
52		}
53
54		globus_result_t
55		wst_StatusCodeEnum_init_wrapper(void **object)
56	0	{
57	0	return wst_StatusCodeEnum_init(
58		(wst_StatusCodeEnum **) object);
59		}
60
61		void
62		wst_StatusCodeEnum_destroy_wrapper(
63		void *                          object)
64	0	{
65	0	wst_StatusCodeEnum_destroy(
66		(wst_StatusCodeEnum *) object);
67		}
68
69		globus_result_t
70		wst_StatusCodeEnum_copy_wrapper(
71		void **                         dest_obj,
72		void *                          src_obj)
73	0	{
74	0	return wst_StatusCodeEnum_copy(
75		(wst_StatusCodeEnum **) dest_obj,
76		(wst_StatusCodeEnum *) src_obj);
77		}
78
79		globus_result_t
80		wst_StatusCodeEnum_init_contents_wrapper(void *object)
81	0	{
82	0	return wst_StatusCodeEnum_init_contents(
83		(wst_StatusCodeEnum *) object);
84		}
85
86		void
87		wst_StatusCodeEnum_destroy_contents_wrapper(
88		void *                          object)
89	0	{
90	0	wst_StatusCodeEnum_destroy_contents(
91		(wst_StatusCodeEnum *) object);
92		}
93
94		globus_result_t
95		wst_StatusCodeEnum_copy_contents_wrapper(
96		void *                          dest_obj,
97		void *                          src_obj)
98	0	{
99	0	return wst_StatusCodeEnum_copy_contents(
100		(wst_StatusCodeEnum *) dest_obj,
101		(wst_StatusCodeEnum *) src_obj);
102		}
103
104		globus_result_t
105		wst_StatusCodeEnum_serialize_contents_wrapper(
106		xsd_QName *                         element_qname,
107		void *                              instance,
108		globus_soap_message_handle_t        message_handle,
109		globus_xsd_element_options_t        options)
110	0	{
111	0	return wst_StatusCodeEnum_serialize_contents(
112		element_qname,
113		(wst_StatusCodeEnum *) instance,
114		message_handle, options);
115		}
116
117		globus_result_t
118		wst_StatusCodeEnum_deserialize_contents_wrapper(
119		xsd_QName *                         element_qname,
120		void **                             instance,
121		globus_soap_message_handle_t        message_handle,
122		globus_xsd_element_options_t        options)
123	0	{
124	0	globus_result_t                     result;
125	0	GlobusFuncName(wst_StatusCodeEnum_deserialize_contents_wrapper);
126	0	GlobusSoapMessageDebugEnter();
127
128	0	if(!*instance)
129		{
130	0	result = wst_StatusCodeEnum_init(
131		(wst_StatusCodeEnum **)instance);
132	0	if(result != GLOBUS_SUCCESS)
133		{
134	0	goto error;
135		}
136		}
137
138	0	result = wst_StatusCodeEnum_deserialize_contents(
139		element_qname,
140		*(wst_StatusCodeEnum **)instance,
141		message_handle, options);
142		error:
143	0	GlobusSoapMessageDebugExit();
144	0	return result;
145		}
146
147		globus_result_t
148		wst_StatusCodeEnum_array_serialize_wrapper(
149		xsd_QName *                     element,
150		void *                          instance,
151		globus_soap_message_handle_t    message,
152		globus_xsd_element_options_t    options)
153	0	{
154	0	return wst_StatusCodeEnum_array_serialize(
155		element,
156		(wst_StatusCodeEnum_array *) instance,
157		message, options);
158		}
159
160		globus_result_t
161		wst_StatusCodeEnum_array_deserialize_wrapper(
162		xsd_QName *                         element_qname,
163		void **                             inst,
164		globus_soap_message_handle_t        message,
165		globus_xsd_element_options_t        options)
166	0	{
167	0	if(!*inst)
168		{
169	0	globus_result_t                 result;
170
171	0	result = wst_StatusCodeEnum_array_init(
172		(wst_StatusCodeEnum_array **)inst);
173	0	if(result != GLOBUS_SUCCESS)
174		{
175	0	return result;
176		}
177		}
178
179	0	return wst_StatusCodeEnum_array_deserialize(
180		element_qname,
181		*(wst_StatusCodeEnum_array **) inst,
182		message, options);
183		}
184
185		globus_result_t
186		wst_StatusCodeEnum_array_init_wrapper(
187		void **                             arr)
188	0	{
189	0	return wst_StatusCodeEnum_array_init(
190		(wst_StatusCodeEnum_array **) arr);
191		}
192
193		void
194		wst_StatusCodeEnum_array_destroy_wrapper(
195		void *                              arr)
196	0	{
197	0	wst_StatusCodeEnum_array_destroy(
198		(wst_StatusCodeEnum_array *) arr);
199		}
200
201		globus_result_t
202		wst_StatusCodeEnum_array_copy_wrapper(
203		void **                             dest_arr,
204		void *                              src_arr)
205	0	{
206	0	return wst_StatusCodeEnum_array_copy(
207		(wst_StatusCodeEnum_array **) dest_arr,
208		(wst_StatusCodeEnum_array *) src_arr);
209		}
210		globus_result_t
211		wst_StatusCodeEnum_array_init_contents_wrapper(
212		void *                              arr)
213	0	{
214	0	return wst_StatusCodeEnum_array_init_contents(
215		(wst_StatusCodeEnum_array *) arr);
216		}
217
218		void
219		wst_StatusCodeEnum_array_destroy_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	wst_StatusCodeEnum_array_destroy_contents(
223		(wst_StatusCodeEnum_array *) arr);
224		}
225
226		globus_result_t
227		wst_StatusCodeEnum_array_copy_contents_wrapper(
228		void *                              dest_arr,
229		void *                              src_arr)
230	0	{
231	0	return wst_StatusCodeEnum_array_copy_contents(
232		(wst_StatusCodeEnum_array *) dest_arr,
233		(wst_StatusCodeEnum_array *) src_arr);
234		}
235
236		struct globus_xsd_type_info_s wst_StatusCodeEnum_array_info =
237		{
238		&wst_StatusCodeEnum_qname,
239		wst_StatusCodeEnum_array_serialize_wrapper,
240		wst_StatusCodeEnum_array_deserialize_wrapper,
241		wst_StatusCodeEnum_array_init_wrapper,
242		wst_StatusCodeEnum_array_destroy_wrapper,
243		wst_StatusCodeEnum_array_copy_wrapper,
244		wst_StatusCodeEnum_array_init_contents_wrapper,
245		wst_StatusCodeEnum_array_destroy_contents_wrapper,
246		wst_StatusCodeEnum_array_copy_contents_wrapper,
247		sizeof(wst_StatusCodeEnum),
248		wst_StatusCodeEnum_array_push_wrapper,
249		NULL,
250		NULL
251		};
252
253		struct globus_xsd_type_info_s wst_StatusCodeEnum_contents_info =
254		{
255		&wst_StatusCodeEnum_qname,
256		wst_StatusCodeEnum_serialize_contents_wrapper,
257		wst_StatusCodeEnum_deserialize_contents_wrapper,
258		wst_StatusCodeEnum_init_wrapper,
259		wst_StatusCodeEnum_destroy_wrapper,
260		wst_StatusCodeEnum_copy_wrapper,
261		wst_StatusCodeEnum_init_contents_wrapper,
262		wst_StatusCodeEnum_destroy_contents_wrapper,
263		wst_StatusCodeEnum_copy_contents_wrapper,
264		sizeof(wst_StatusCodeEnum),
265		NULL,
266		NULL,
267		NULL
268		};
269
270		struct globus_xsd_type_info_s wst_StatusCodeEnum_info =
271		{
272		&wst_StatusCodeEnum_qname,
273		wst_StatusCodeEnum_serialize_wrapper,
274		wst_StatusCodeEnum_deserialize_pointer_wrapper,
275		wst_StatusCodeEnum_init_wrapper,
276		wst_StatusCodeEnum_destroy_wrapper,
277		wst_StatusCodeEnum_copy_wrapper,
278		wst_StatusCodeEnum_init_contents_wrapper,
279		wst_StatusCodeEnum_destroy_contents_wrapper,
280		wst_StatusCodeEnum_copy_contents_wrapper,
281		sizeof(wst_StatusCodeEnum),
282		NULL,
283		&wst_StatusCodeEnum_contents_info,
284		&wst_StatusCodeEnum_array_info
285		};
286
287		globus_result_t
288		wst_StatusCodeEnum_init_contents(
289		wst_StatusCodeEnum * instance)
290	0	{
291	0	globus_result_t                     result = GLOBUS_SUCCESS;
292	0	GlobusFuncName(wst_StatusCodeEnum_init_contents);
293	0	GlobusSoapMessageDebugEnter();
294
295
296	0	xsd_anyURI_init_contents(instance);
297
298	0	GlobusSoapMessageDebugExit();
299	0	return result;
300		}
301
302		globus_result_t
303		wst_StatusCodeEnum_init(
304		wst_StatusCodeEnum ** object)
305	0	{
306	0	wst_StatusCodeEnum * instance;
307	0	globus_result_t                     result = GLOBUS_SUCCESS;
308	0	GlobusFuncName(wst_StatusCodeEnum_init);
309	0	GlobusSoapMessageDebugEnter();
310
311
312	0	xsd_anyURI_init(object);
313
314	0	GlobusSoapMessageDebugExit();
315	0	return result;
316		}
317
318		void
319		wst_StatusCodeEnum_destroy(
320		wst_StatusCodeEnum * instance)
321	0	{
322	0	GlobusFuncName(wst_StatusCodeEnum_destroy);
323	0	GlobusSoapMessageDebugEnter();
324
325	0	if(!instance)
326		{
327	0	goto exit;
328		}
329
330	0	wst_StatusCodeEnum_destroy_contents(instance);
331	0	globus_free(instance);
332
333		exit:
334
335	0	GlobusSoapMessageDebugExit();
336		}
337
338		void
339		wst_StatusCodeEnum_destroy_contents(
340		wst_StatusCodeEnum * instance)
341	0	{
342	0	GlobusFuncName(wst_StatusCodeEnum_destroy_contents);
343	0	GlobusSoapMessageDebugEnter();
344
345	0	if(instance)
346		{
347
348
349	0	xsd_anyURI_destroy_contents(instance);
350
351		}
352
353	0	GlobusSoapMessageDebugExit();
354		}
355
356		globus_result_t
357		wst_StatusCodeEnum_copy(
358		wst_StatusCodeEnum ** dest_obj,
359		const wst_StatusCodeEnum * src_obj)
360	0	{
361	0	globus_result_t                     result = GLOBUS_SUCCESS;
362	0	wst_StatusCodeEnum * instance;
363	0	GlobusFuncName(wst_StatusCodeEnum_copy);
364
365	0	GlobusSoapMessageDebugEnter();
366
367	0	instance = malloc(sizeof(wst_StatusCodeEnum));
368	0	if (instance == NULL)
369		{
370	0	GlobusSoapMessageDebugExit();
371	0	return GlobusSoapMessageErrorOutOfMemory;
372		}
373
374	0	result = wst_StatusCodeEnum_copy_contents(instance, src_obj);
375	0	if(result != GLOBUS_SUCCESS)
376		{
377	0	globus_free(instance);
378	0	GlobusSoapMessageDebugExit();
379	0	return GlobusSoapMessageErrorOutOfMemory;
380		}
381
382	0	*dest_obj = instance;
383	0	GlobusSoapMessageDebugExit();
384	0	return result;
385		}
386
387		globus_result_t
388		wst_StatusCodeEnum_copy_contents(
389		wst_StatusCodeEnum * instance,
390		const wst_StatusCodeEnum * src_obj)
391	0	{
392	0	globus_result_t                     result = GLOBUS_SUCCESS;
393	0	GlobusFuncName(wst_StatusCodeEnum_copy_contents);
394
395	0	GlobusSoapMessageDebugEnter();
396
397
398	0	result = xsd_anyURI_copy_contents(
399		instance, src_obj);
400
401	0	goto exit;
402
403		fail_copy:
404
405
406		exit:
407
408	0	GlobusSoapMessageDebugExit();
409	0	return result;
410		}
411
412
413
414		globus_result_t
415		wst_StatusCodeEnum_serialize_contents(
416		xsd_QName *                         element_qname, /* ignored */
417		wst_StatusCodeEnum * inst,
418		globus_soap_message_handle_t        message_handle,
419		globus_xsd_element_options_t        options)
420	0	{
421	0	globus_result_t                     result = GLOBUS_SUCCESS;
422	0	GlobusFuncName(wst_StatusCodeEnum_serialize_contents);
423	0	GlobusSoapMessageDebugEnter();
424
425	0	result = wst_StatusCodeEnum_serialize(
426		NULL,
427		inst,
428		message_handle,
429		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
430	0	if(result != GLOBUS_SUCCESS)
431		{
432	0	result = GlobusSoapMessageErrorSerializeFailed(
433		result, NULL, element_qname);
434		goto exit;
435		}
436
437		exit:
438
439	0	GlobusSoapMessageDebugExit();
440	0	return result;
441		}
442
443
444
445		globus_result_t
446		wst_StatusCodeEnum_serialize(
447		xsd_QName *                         element_qname,
448		wst_StatusCodeEnum * instance,
449		globus_soap_message_handle_t        message_handle,
450		globus_xsd_element_options_t        options)
451	0	{
452	0	globus_result_t                     result = GLOBUS_SUCCESS;
453	0	xsd_QName                           subelement;
454	0	globus_list_t *                     any_attr_keys = NULL;
455	0	globus_list_t *                     any_attr_keys_iterator = NULL;
456	0	xsd_QName *                         type_attr = NULL;
457	0	char *                              type_value = NULL;
458	0	char *                              prefix = NULL;
459	0	int                                 prefix_created;
460	0	int                                 define_prefix = 0;
461	0	char *                              type_attr_prefix = NULL;
462
463	0	GlobusFuncName(wst_StatusCodeEnum_serialize);
464	0	GlobusSoapMessageDebugEnter();
465
466
467	0	result = xsd_anyURI_serialize(
468		element_qname,
469		instance,
470		message_handle,
471		options);
472
473		exit:
474
475	0	if(any_attr_keys)
476		{
477	0	globus_list_free(any_attr_keys);
478		}
479
480	0	GlobusSoapMessageDebugExit();
481	0	return result;
482		}
483
484
485
486		globus_result_t
487		wst_StatusCodeEnum_deserialize_contents(
488		xsd_QName *                         element_qname, /* ignored */
489		wst_StatusCodeEnum * inst,
490		globus_soap_message_handle_t        message_handle,
491		globus_xsd_element_options_t        options)
492	0	{
493	0	globus_result_t                     result = GLOBUS_SUCCESS;
494	0	GlobusFuncName(wst_StatusCodeEnum_deserialize_contents);
495	0	GlobusSoapMessageDebugEnter();
496
497	0	result = wst_StatusCodeEnum_deserialize(
498		NULL,
499		inst,
500		message_handle,
501		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
502	0	if(result != GLOBUS_SUCCESS)
503		{
504	0	result = GlobusSoapMessageErrorDeserializeFailed(
505		result, element_qname);
506		goto exit;
507		}
508
509		exit:
510
511	0	GlobusSoapMessageDebugExit();
512	0	return result;
513		}
514
515
516
517		globus_result_t
518		wst_StatusCodeEnum_deserialize(
519		xsd_QName *                         element_qname,
520		wst_StatusCodeEnum * instance,
521		globus_soap_message_handle_t        message_handle,
522		globus_xsd_element_options_t        options)
523	0	{
524	0	globus_result_t                     result = GLOBUS_SUCCESS;
525	0	xsd_QName                           subelement;
526	0	GlobusFuncName(wst_StatusCodeEnum_deserialize);
527	0	GlobusSoapMessageDebugEnter();
528
529
530	0	result = xsd_anyURI_deserialize(element_qname,
531		instance, message_handle, options);
532
533
534		exit:
535
536	0	GlobusSoapMessageDebugExit();
537	0	return result;
538		}
539
540
541
542		globus_result_t
543		wst_StatusCodeEnum_deserialize_pointer(
544		xsd_QName *                         element_qname,
545		wst_StatusCodeEnum ** ip,
546		globus_soap_message_handle_t        message_handle,
547		globus_xsd_element_options_t        options)
548	0	{
549	0	wst_StatusCodeEnum * instance = NULL;
550	0	globus_result_t                     result = GLOBUS_SUCCESS;
551	0	xsd_QName                           subelement;
552	0	GlobusFuncName(wst_StatusCodeEnum_deserialize_pointer);
553	0	GlobusSoapMessageDebugEnter();
554
555	0	*ip = NULL;
556
557
558	0	result = xsd_anyURI_deserialize_pointer(
559		element_qname,
560		ip, message_handle, options);
561
562
563		exit:
564
565	0	GlobusSoapMessageDebugExit();
566	0	return result;
567		}
568
569
570
571		globus_result_t
572		wst_StatusCodeEnum_array_init_contents(
573		wst_StatusCodeEnum_array * array)
574	0	{
575	0	GlobusFuncName(wst_StatusCodeEnum_array_init_contents);
576	0	GlobusSoapMessageDebugEnter();
577
578	0	memset(array, 0, sizeof(wst_StatusCodeEnum_array));
579
580	0	GlobusSoapMessageDebugExit();
581	0	return GLOBUS_SUCCESS;
582		}
583
584		globus_result_t
585		wst_StatusCodeEnum_array_init(
586		wst_StatusCodeEnum_array ** arr)
587	0	{
588	0	wst_StatusCodeEnum_array * array;
589	0	globus_result_t                     result;
590	0	GlobusFuncName(wst_StatusCodeEnum_array_init);
591	0	GlobusSoapMessageDebugEnter();
592
593	0	array = (wst_StatusCodeEnum_array *)
594		globus_malloc(sizeof(wst_StatusCodeEnum_array));
595	0	if(!array)
596		{
597	0	result = GlobusSoapMessageErrorOutOfMemory;
598	0	GlobusSoapMessageDebugExit();
599	0	return result;
600		}
601
602	0	result = wst_StatusCodeEnum_array_init_contents(array);
603	0	if(result != GLOBUS_SUCCESS)
604		{
605	0	globus_free(array);
606	0	array = NULL;
607
608		}
609
610	0	*arr = array;
611
612	0	GlobusSoapMessageDebugExit();
613	0	return result;
614		}
615
616		void
617		wst_StatusCodeEnum_array_destroy_contents(
618		wst_StatusCodeEnum_array * array)
619	0	{
620	0	int                                 i = 0;
621	0	GlobusFuncName(wst_StatusCodeEnum_array_destroy_contents);
622	0	GlobusSoapMessageDebugEnter();
623
624	0	for(; i < array->length; ++i)
625		{
626	0	wst_StatusCodeEnum_destroy_contents(&array->elements[i]);
627		}
628
629	0	if(array->elements)
630		{
631	0	globus_free(array->elements);
632	0	array->elements = NULL;
633		}
634	0	array->length = 0;
635
636	0	GlobusSoapMessageDebugExit();
637		}
638
639		void
640		wst_StatusCodeEnum_array_destroy(
641		wst_StatusCodeEnum_array * array)
642	0	{
643	0	GlobusFuncName(wst_StatusCodeEnum_array_destroy);
644	0	GlobusSoapMessageDebugEnter();
645
646	0	wst_StatusCodeEnum_array_destroy_contents(array);
647	0	globus_free(array);
648
649	0	GlobusSoapMessageDebugExit();
650		}
651
652		globus_result_t
653		wst_StatusCodeEnum_array_copy(
654		wst_StatusCodeEnum_array ** dest_arr,
655		const wst_StatusCodeEnum_array * src_arr)
656	0	{
657	0	wst_StatusCodeEnum_array * array;
658	0	globus_result_t                     result;
659	0	GlobusFuncName(wst_StatusCodeEnum_array_copy);
660	0	GlobusSoapMessageDebugEnter();
661
662	0	array = (wst_StatusCodeEnum_array *) malloc(
663		sizeof(wst_StatusCodeEnum_array));
664	0	if(!array)
665		{
666	0	result = GlobusSoapMessageErrorOutOfMemory;
667	0	GlobusSoapMessageDebugExit();
668	0	return result;
669		}
670
671	0	result = wst_StatusCodeEnum_array_copy_contents(array, src_arr);
672	0	if(result != GLOBUS_SUCCESS)
673		{
674	0	globus_free(array);
675	0	GlobusSoapMessageDebugExit();
676	0	return result;
677		}
678
679	0	*dest_arr = array;
680
681	0	GlobusSoapMessageDebugExit();
682	0	return GLOBUS_SUCCESS;
683		}
684
685		globus_result_t
686		wst_StatusCodeEnum_array_copy_contents(
687		wst_StatusCodeEnum_array * dest_arr,
688		const wst_StatusCodeEnum_array * src_arr)
689	0	{
690	0	int                                 i;
691	0	globus_result_t                     result = GLOBUS_SUCCESS;
692	0	GlobusFuncName(wst_StatusCodeEnum_array_copy_contents);
693	0	GlobusSoapMessageDebugEnter();
694
695	0	dest_arr->length = src_arr->length;
696	0	if(dest_arr->length > 0)
697		{
698	0	dest_arr->elements = (wst_StatusCodeEnum *) malloc(
699		sizeof(wst_StatusCodeEnum) * dest_arr->length);
700	0	if(!dest_arr->elements)
701		{
702	0	result = GlobusSoapMessageErrorOutOfMemory;
703	0	GlobusSoapMessageDebugExit();
704	0	return result;
705		}
706		}
707		else
708		{
709	0	dest_arr->elements = NULL;
710		}
711
712	0	for(i = 0; i < dest_arr->length; i++)
713		{
714	0	result = wst_StatusCodeEnum_copy_contents(
715		&dest_arr->elements[i], &src_arr->elements[i]);
716	0	if(result != GLOBUS_SUCCESS)
717		{
718	0	while(i--)
719		{
720	0	wst_StatusCodeEnum_destroy_contents(&dest_arr->elements[i]);
721		}
722
723	0	globus_free(dest_arr->elements);
724	0	dest_arr->elements = NULL;
725	0	dest_arr->length = 0;
726	0	break;
727		}
728		}
729
730	0	GlobusSoapMessageDebugExit();
731	0	return result;
732		}
733
734		wst_StatusCodeEnum *
735		wst_StatusCodeEnum_array_push(
736		wst_StatusCodeEnum_array * array)
737	0	{
738	0	GlobusFuncName(wst_StatusCodeEnum_array_push);
739	0	GlobusSoapMessageDebugEnter();
740
741	0	array->elements = realloc(array->elements,
742		sizeof(wst_StatusCodeEnum) *
743		(array->length + 1));
744	0	memset(&array->elements[array->length], 0, sizeof(wst_StatusCodeEnum));
745	0	array->length++;
746
747	0	GlobusSoapMessageDebugExit();
748	0	return (&array->elements[array->length - 1]);
749		}
750
751		void *
752		wst_StatusCodeEnum_array_push_wrapper(
753		void * array)
754	0	{
755	0	return (void *) wst_StatusCodeEnum_array_push((wst_StatusCodeEnum_array *) array);
756		}
757
758		globus_result_t
759		wst_StatusCodeEnum_array_serialize(
760		xsd_QName *                         element_qname,
761		wst_StatusCodeEnum_array * array,
762		globus_soap_message_handle_t        message,
763		globus_xsd_element_options_t        options)
764	0	{
765	0	globus_result_t                     result = GLOBUS_SUCCESS;
766	0	int                                 i = 0;
767	0	GlobusFuncName(wst_StatusCodeEnum_array_serialize);
768	0	GlobusSoapMessageDebugEnter();
769
770	0	for(; i < array->length; ++i)
771		{
772	0	result = wst_StatusCodeEnum_serialize(
773		element_qname,
774		&array->elements[i],
775		message,
776		options);
777	0	if(result != GLOBUS_SUCCESS)
778		{
779	0	goto exit;
780		}
781		}
782
783		exit:
784
785	0	GlobusSoapMessageDebugExit();
786	0	return result;
787		}
788
789		globus_result_t
790		wst_StatusCodeEnum_array_deserialize(
791		xsd_QName *                         element_qname,
792		wst_StatusCodeEnum_array * array,
793		globus_soap_message_handle_t        message,
794		globus_xsd_element_options_t        options)
795	0	{
796	0	globus_result_t                     result = GLOBUS_SUCCESS;
797	0	int                                 i = 0;
798	0	int                                 pre_length;
799	0	GlobusFuncName(wst_StatusCodeEnum_array_deserialize);
800	0	GlobusSoapMessageDebugEnter();
801
802	0	pre_length = array->length;
803
804	0	for(i = 0; i < pre_length; ++i)
805		{
806	0	result = wst_StatusCodeEnum_deserialize(
807		element_qname,
808		&array->elements[i],
809		message,
810		options);
811	0	if(result != GLOBUS_SUCCESS)
812		{
813	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
814		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
815		GlobusSoapMessageStatusFailedWithTextCheck(result))
816		{
817	0	result = GLOBUS_SUCCESS;
818	0	break;
819		}
820
821	0	result = GlobusSoapMessageErrorDeserializeFailed(
822		result, element_qname);
823	0	goto exit;
824		}
825		}
826
827	0	while(result == GLOBUS_SUCCESS)
828		{
829	0	wst_StatusCodeEnum                  next;
830	0	memset(&next, 0, sizeof(wst_StatusCodeEnum));
831
832	0	result = wst_StatusCodeEnum_deserialize(
833		element_qname,
834		&next,
835		message,
836		options);
837	0	if(result != GLOBUS_SUCCESS)
838		{
839	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
840		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
841		GlobusSoapMessageStatusFailedWithTextCheck(result))
842		{
843	0	result = GLOBUS_SUCCESS;
844	0	break;
845		}
846
847	0	result = GlobusSoapMessageErrorDeserializeFailed(
848		result, element_qname);
849	0	goto exit;
850		}
851
852	0	array->elements = realloc(
853		array->elements,
854		(array->length + 1) * sizeof(wst_StatusCodeEnum));
855	0	if(!array->elements)
856		{
857	0	result = GlobusSoapMessageErrorOutOfMemory;
858	0	goto exit;
859		}
860	0	array->elements[array->length] = next;
861	0	array->length++;
862	0	++i;
863		}
864
865		exit:
866
867	0	if(result != GLOBUS_SUCCESS)
868		{
869	0	int                             di = 0;
870	0	for(; di < i; ++di)
871		{
872	0	wst_StatusCodeEnum_destroy_contents(
873		&array->elements[di]);
874	0	memset(&array->elements[di], 0, sizeof(wst_StatusCodeEnum));
875		}
876		}
877
878	0	GlobusSoapMessageDebugExit();
879	0	return result;
880		}
881
882
883		globus_result_t
884		wst_StatusCodeEnum_serialize_attribute(
885		xsd_QName *                         attr_qname,
886		wst_StatusCodeEnum * val,
887		globus_soap_message_handle_t        handle,
888		globus_xsd_element_options_t        options)
889	0	{
890	0	globus_result_t                     result = GLOBUS_SUCCESS;
891	0	GlobusFuncName(wst_StatusCodeEnum_serialize_attribute);
892	0	GlobusSoapMessageDebugEnter();
893
894
895	0	result = xsd_anyURI_serialize_attribute(
896		attr_qname, (xsd_anyURI *)val, handle, options);
897	0	if(result != GLOBUS_SUCCESS)
898		{
899	0	result = GlobusSoapMessageErrorSerializeFailed(
900		result, NULL, attr_qname);
901		goto exit;
902		}
903
904		exit:
905
906	0	GlobusSoapMessageDebugExit();
907	0	return result;
908		}
909
910		globus_result_t
911		wst_StatusCodeEnum_deserialize_attribute(
912		xsd_QName *                         attr_qname,
913		wst_StatusCodeEnum * instance,
914		globus_soap_message_handle_t        message,
915		globus_xsd_element_options_t        options)
916	0	{
917	0	globus_result_t                     result = GLOBUS_SUCCESS;
918	0	GlobusFuncName(wst_StatusCodeEnum_deserialize_attribute);
919	0	GlobusSoapMessageDebugEnter();
920
921
922	0	result = xsd_anyURI_deserialize_attribute(
923		attr_qname, (xsd_anyURI *)instance, message, options);
924
925	0	if(result != GLOBUS_SUCCESS)
926		{
927	0	result = GlobusSoapMessageErrorDeserializeFailed(
928		result, attr_qname);
929		goto exit;
930		}
931
932		exit:
933
934	0	GlobusSoapMessageDebugExit();
935	0	return result;
936		}
937
938		globus_result_t
939		wst_StatusCodeEnum_deserialize_attribute_pointer(
940		xsd_QName *                         attr_qname,
941		wst_StatusCodeEnum ** instance,
942		globus_soap_message_handle_t        message,
943		globus_xsd_element_options_t        options)
944	0	{
945	0	globus_result_t                     result = GLOBUS_SUCCESS;
946	0	GlobusFuncName(wst_StatusCodeEnum_deserialize_attribute_pointer);
947	0	GlobusSoapMessageDebugEnter();
948
949
950	0	result = xsd_anyURI_deserialize_attribute_pointer(
951		attr_qname, (xsd_anyURI **)instance, message, options);
952
953	0	if(result != GLOBUS_SUCCESS)
954		{
955	0	result = GlobusSoapMessageErrorDeserializeFailed(
956		result, attr_qname);
957		goto exit;
958		}
959
960		exit:
961
962	0	GlobusSoapMessageDebugExit();
963	0	return result;