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