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