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