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 "wsp_OpenUsageType.h"
21
22		xsd_QName wsp_OpenUsageType_qname =
23		{
24		"http://schemas.xmlsoap.org/ws/2002/12/policy",
25		"OpenUsageType"
26		};
27
28		globus_result_t
29		wsp_OpenUsageType_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 wsp_OpenUsageType_serialize(
36		element_qname,
37		(wsp_OpenUsageType *) instance,
38		message_handle, options);
39		}
40
41		globus_result_t
42		wsp_OpenUsageType_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 wsp_OpenUsageType_deserialize_pointer(
49		element_qname,
50		(wsp_OpenUsageType **) ip,
51		message_handle, options);
52		}
53
54		globus_result_t
55		wsp_OpenUsageType_init_wrapper(void **object)
56	0	{
57	0	return wsp_OpenUsageType_init(
58		(wsp_OpenUsageType **) object);
59		}
60
61		void
62		wsp_OpenUsageType_destroy_wrapper(
63		void *                          object)
64	0	{
65	0	wsp_OpenUsageType_destroy(
66		(wsp_OpenUsageType *) object);
67		}
68
69		globus_result_t
70		wsp_OpenUsageType_copy_wrapper(
71		void **                         dest_obj,
72		void *                          src_obj)
73	0	{
74	0	return wsp_OpenUsageType_copy(
75		(wsp_OpenUsageType **) dest_obj,
76		(wsp_OpenUsageType *) src_obj);
77		}
78
79		globus_result_t
80		wsp_OpenUsageType_init_contents_wrapper(void *object)
81	0	{
82	0	return wsp_OpenUsageType_init_contents(
83		(wsp_OpenUsageType *) object);
84		}
85
86		void
87		wsp_OpenUsageType_destroy_contents_wrapper(
88		void *                          object)
89	0	{
90	0	wsp_OpenUsageType_destroy_contents(
91		(wsp_OpenUsageType *) object);
92		}
93
94		globus_result_t
95		wsp_OpenUsageType_copy_contents_wrapper(
96		void *                          dest_obj,
97		void *                          src_obj)
98	0	{
99	0	return wsp_OpenUsageType_copy_contents(
100		(wsp_OpenUsageType *) dest_obj,
101		(wsp_OpenUsageType *) src_obj);
102		}
103
104		globus_result_t
105		wsp_OpenUsageType_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 wsp_OpenUsageType_serialize_contents(
112		element_qname,
113		(wsp_OpenUsageType *) instance,
114		message_handle, options);
115		}
116
117		globus_result_t
118		wsp_OpenUsageType_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(wsp_OpenUsageType_deserialize_contents_wrapper);
126	0	GlobusSoapMessageDebugEnter();
127
128	0	if(!*instance)
129		{
130	0	result = wsp_OpenUsageType_init(
131		(wsp_OpenUsageType **)instance);
132	0	if(result != GLOBUS_SUCCESS)
133		{
134	0	goto error;
135		}
136		}
137
138	0	result = wsp_OpenUsageType_deserialize_contents(
139		element_qname,
140		*(wsp_OpenUsageType **)instance,
141		message_handle, options);
142		error:
143	0	GlobusSoapMessageDebugExit();
144	0	return result;
145		}
146
147		globus_result_t
148		wsp_OpenUsageType_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 wsp_OpenUsageType_array_serialize(
155		element,
156		(wsp_OpenUsageType_array *) instance,
157		message, options);
158		}
159
160		globus_result_t
161		wsp_OpenUsageType_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 = wsp_OpenUsageType_array_init(
172		(wsp_OpenUsageType_array **)inst);
173	0	if(result != GLOBUS_SUCCESS)
174		{
175	0	return result;
176		}
177		}
178
179	0	return wsp_OpenUsageType_array_deserialize(
180		element_qname,
181		*(wsp_OpenUsageType_array **) inst,
182		message, options);
183		}
184
185		globus_result_t
186		wsp_OpenUsageType_array_init_wrapper(
187		void **                             arr)
188	0	{
189	0	return wsp_OpenUsageType_array_init(
190		(wsp_OpenUsageType_array **) arr);
191		}
192
193		void
194		wsp_OpenUsageType_array_destroy_wrapper(
195		void *                              arr)
196	0	{
197	0	wsp_OpenUsageType_array_destroy(
198		(wsp_OpenUsageType_array *) arr);
199		}
200
201		globus_result_t
202		wsp_OpenUsageType_array_copy_wrapper(
203		void **                             dest_arr,
204		void *                              src_arr)
205	0	{
206	0	return wsp_OpenUsageType_array_copy(
207		(wsp_OpenUsageType_array **) dest_arr,
208		(wsp_OpenUsageType_array *) src_arr);
209		}
210		globus_result_t
211		wsp_OpenUsageType_array_init_contents_wrapper(
212		void *                              arr)
213	0	{
214	0	return wsp_OpenUsageType_array_init_contents(
215		(wsp_OpenUsageType_array *) arr);
216		}
217
218		void
219		wsp_OpenUsageType_array_destroy_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	wsp_OpenUsageType_array_destroy_contents(
223		(wsp_OpenUsageType_array *) arr);
224		}
225
226		globus_result_t
227		wsp_OpenUsageType_array_copy_contents_wrapper(
228		void *                              dest_arr,
229		void *                              src_arr)
230	0	{
231	0	return wsp_OpenUsageType_array_copy_contents(
232		(wsp_OpenUsageType_array *) dest_arr,
233		(wsp_OpenUsageType_array *) src_arr);
234		}
235
236		struct globus_xsd_type_info_s wsp_OpenUsageType_array_info =
237		{
238		&wsp_OpenUsageType_qname,
239		wsp_OpenUsageType_array_serialize_wrapper,
240		wsp_OpenUsageType_array_deserialize_wrapper,
241		wsp_OpenUsageType_array_init_wrapper,
242		wsp_OpenUsageType_array_destroy_wrapper,
243		wsp_OpenUsageType_array_copy_wrapper,
244		wsp_OpenUsageType_array_init_contents_wrapper,
245		wsp_OpenUsageType_array_destroy_contents_wrapper,
246		wsp_OpenUsageType_array_copy_contents_wrapper,
247		sizeof(wsp_OpenUsageType),
248		wsp_OpenUsageType_array_push_wrapper,
249		NULL,
250		NULL
251		};
252
253		struct globus_xsd_type_info_s wsp_OpenUsageType_contents_info =
254		{
255		&wsp_OpenUsageType_qname,
256		wsp_OpenUsageType_serialize_contents_wrapper,
257		wsp_OpenUsageType_deserialize_contents_wrapper,
258		wsp_OpenUsageType_init_wrapper,
259		wsp_OpenUsageType_destroy_wrapper,
260		wsp_OpenUsageType_copy_wrapper,
261		wsp_OpenUsageType_init_contents_wrapper,
262		wsp_OpenUsageType_destroy_contents_wrapper,
263		wsp_OpenUsageType_copy_contents_wrapper,
264		sizeof(wsp_OpenUsageType),
265		NULL,
266		NULL,
267		NULL
268		};
269
270		struct globus_xsd_type_info_s wsp_OpenUsageType_info =
271		{
272		&wsp_OpenUsageType_qname,
273		wsp_OpenUsageType_serialize_wrapper,
274		wsp_OpenUsageType_deserialize_pointer_wrapper,
275		wsp_OpenUsageType_init_wrapper,
276		wsp_OpenUsageType_destroy_wrapper,
277		wsp_OpenUsageType_copy_wrapper,
278		wsp_OpenUsageType_init_contents_wrapper,
279		wsp_OpenUsageType_destroy_contents_wrapper,
280		wsp_OpenUsageType_copy_contents_wrapper,
281		sizeof(wsp_OpenUsageType),
282		NULL,
283		&wsp_OpenUsageType_contents_info,
284		&wsp_OpenUsageType_array_info
285		};
286
287		globus_result_t
288		wsp_OpenUsageType_init_contents(
289		wsp_OpenUsageType * instance)
290	0	{
291	0	globus_result_t                     result = GLOBUS_SUCCESS;
292	0	GlobusFuncName(wsp_OpenUsageType_init_contents);
293	0	GlobusSoapMessageDebugEnter();
294
295
296	0	result = xsd_QName_init_contents((xsd_QName *) instance);
297
298	0	GlobusSoapMessageDebugExit();
299	0	return result;
300		}
301
302		globus_result_t
303		wsp_OpenUsageType_init(
304		wsp_OpenUsageType ** object)
305	0	{
306	0	wsp_OpenUsageType * instance;
307	0	globus_result_t                     result = GLOBUS_SUCCESS;
308	0	GlobusFuncName(wsp_OpenUsageType_init);
309	0	GlobusSoapMessageDebugEnter();
310
311
312
313	0	instance = (wsp_OpenUsageType *)
314		globus_malloc(sizeof(wsp_OpenUsageType));
315	0	if(!instance)
316		{
317	0	result = GlobusSoapMessageErrorOutOfMemory;
318	0	GlobusSoapMessageDebugExit();
319	0	return result;
320		}
321
322	0	memset(instance, 0, sizeof(wsp_OpenUsageType));
323
324	0	*object = instance;
325
326	0	GlobusSoapMessageDebugExit();
327	0	return result;
328		}
329
330		void
331		wsp_OpenUsageType_destroy(
332		wsp_OpenUsageType * instance)
333	0	{
334	0	GlobusFuncName(wsp_OpenUsageType_destroy);
335	0	GlobusSoapMessageDebugEnter();
336
337	0	if(!instance)
338		{
339	0	goto exit;
340		}
341
342	0	wsp_OpenUsageType_destroy_contents(instance);
343	0	globus_free(instance);
344
345		exit:
346
347	0	GlobusSoapMessageDebugExit();
348		}
349
350		void
351		wsp_OpenUsageType_destroy_contents(
352		wsp_OpenUsageType * instance)
353	0	{
354	0	GlobusFuncName(wsp_OpenUsageType_destroy_contents);
355	0	GlobusSoapMessageDebugEnter();
356
357	0	if(instance)
358		{
359
360
361	0	xsd_QName_destroy_contents((xsd_QName *)instance);
362
363		}
364
365	0	GlobusSoapMessageDebugExit();
366		}
367
368		globus_result_t
369		wsp_OpenUsageType_copy(
370		wsp_OpenUsageType ** dest_obj,
371		const wsp_OpenUsageType * src_obj)
372	0	{
373	0	globus_result_t                     result = GLOBUS_SUCCESS;
374	0	wsp_OpenUsageType * instance;
375	0	GlobusFuncName(wsp_OpenUsageType_copy);
376
377	0	GlobusSoapMessageDebugEnter();
378
379	0	instance = malloc(sizeof(wsp_OpenUsageType));
380	0	if (instance == NULL)
381		{
382	0	GlobusSoapMessageDebugExit();
383	0	return GlobusSoapMessageErrorOutOfMemory;
384		}
385
386	0	result = wsp_OpenUsageType_copy_contents(instance, src_obj);
387	0	if(result != GLOBUS_SUCCESS)
388		{
389	0	globus_free(instance);
390	0	GlobusSoapMessageDebugExit();
391	0	return GlobusSoapMessageErrorOutOfMemory;
392		}
393
394	0	*dest_obj = instance;
395	0	GlobusSoapMessageDebugExit();
396	0	return result;
397		}
398
399		globus_result_t
400		wsp_OpenUsageType_copy_contents(
401		wsp_OpenUsageType * instance,
402		const wsp_OpenUsageType * src_obj)
403	0	{
404	0	globus_result_t                     result = GLOBUS_SUCCESS;
405	0	GlobusFuncName(wsp_OpenUsageType_copy_contents);
406
407	0	GlobusSoapMessageDebugEnter();
408
409
410	0	result = xsd_QName_copy_contents(
411		(xsd_QName *)instance, (const xsd_QName *) src_obj);
412	0	goto exit;
413
414	0	goto exit;
415
416		fail_copy:
417
418
419		exit:
420
421	0	GlobusSoapMessageDebugExit();
422	0	return result;
423		}
424
425
426
427		globus_result_t
428		wsp_OpenUsageType_serialize_contents(
429		xsd_QName *                         element_qname, /* ignored */
430		wsp_OpenUsageType * inst,
431		globus_soap_message_handle_t        message_handle,
432		globus_xsd_element_options_t        options)
433	0	{
434	0	globus_result_t                     result = GLOBUS_SUCCESS;
435	0	GlobusFuncName(wsp_OpenUsageType_serialize_contents);
436	0	GlobusSoapMessageDebugEnter();
437
438	0	result = wsp_OpenUsageType_serialize(
439		NULL,
440		inst,
441		message_handle,
442		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
443	0	if(result != GLOBUS_SUCCESS)
444		{
445	0	result = GlobusSoapMessageErrorSerializeFailed(
446		result, NULL, element_qname);
447		goto exit;
448		}
449
450		exit:
451
452	0	GlobusSoapMessageDebugExit();
453	0	return result;
454		}
455
456
457
458		globus_result_t
459		wsp_OpenUsageType_serialize(
460		xsd_QName *                         element_qname,
461		wsp_OpenUsageType * instance,
462		globus_soap_message_handle_t        message_handle,
463		globus_xsd_element_options_t        options)
464	0	{
465	0	globus_result_t                     result = GLOBUS_SUCCESS;
466	0	xsd_QName                           subelement;
467	0	globus_list_t *                     any_attr_keys = NULL;
468	0	globus_list_t *                     any_attr_keys_iterator = NULL;
469	0	xsd_QName *                         type_attr = NULL;
470	0	char *                              type_value = NULL;
471	0	char *                              prefix = NULL;
472	0	int                                 prefix_created;
473	0	int                                 define_prefix = 0;
474	0	char *                              type_attr_prefix = NULL;
475
476	0	GlobusFuncName(wsp_OpenUsageType_serialize);
477	0	GlobusSoapMessageDebugEnter();
478
479
480
481	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
482		{
483
484		/* serialize wsp_OpenUsageType element */
485
486	0	result = globus_soap_message_invoke_ns_callouts(
487		message_handle,
488		element_qname,
489		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_SET,
490		&options);
491	0	if(result != GLOBUS_SUCCESS)
492		{
493	0	result = GlobusSoapMessageErrorSerializeFailed(
494		result, NULL, element_qname);
495	0	goto exit;
496		}
497
498	0	result = globus_soap_message_element_ns_set(
499		message_handle,
500		element_qname->Namespace,
501		&options);
502	0	if(result != GLOBUS_SUCCESS)
503		{
504	0	result = GlobusSoapMessageErrorSerializeFailed(
505		result, NULL, element_qname);
506	0	goto exit;
507		}
508
509	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
510		!globus_soap_message_serialize_is_c14n_subset(message_handle))
511		{
512	0	result = globus_soap_message_attribute_ns_set(
513		message_handle,
514		"http://www.w3.org/2001/XMLSchema-instance",
515		&options);
516	0	if(result != GLOBUS_SUCCESS)
517		{
518	0	result = GlobusSoapMessageErrorSerializeFailed(
519		result, NULL, element_qname);
520	0	goto exit;
521		}
522
523	0	result = globus_soap_message_attribute_ns_set(
524		message_handle,
525		wsp_OpenUsageType_qname.Namespace,
526		&options);
527	0	if(result != GLOBUS_SUCCESS)
528		{
529	0	result = GlobusSoapMessageErrorSerializeFailed(
530		result, NULL, element_qname);
531	0	goto exit;
532		}
533		}
534
535	0	result = globus_soap_message_invoke_callouts(
536		message_handle,
537		element_qname,
538		GLOBUS_SOAP_MESSAGE_CALLOUT_BEGIN);
539	0	if(result != GLOBUS_SUCCESS)
540		{
541	0	result = GlobusSoapMessageErrorSerializeFailed(
542		result, NULL, element_qname);
543	0	goto exit;
544		}
545
546	0	result = globus_soap_message_serialize_element(
547		message_handle,
548		element_qname,
549		options,
550		&wsp_OpenUsageType_qname);
551	0	if(result != GLOBUS_SUCCESS)
552		{
553	0	result = GlobusSoapMessageErrorSerializeFailed(
554		result, NULL, element_qname);
555	0	goto exit;
556		}
557
558	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
559		!globus_soap_message_serialize_is_c14n_subset(message_handle))
560		{
561	0	xsd_QName_init(&type_attr);
562
563	0	type_attr->local = globus_libc_strdup("type");
564	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
565
566	0	if(prefix)
567		{
568	0	type_value = globus_common_create_string(
569		"%s:%s", type_attr_prefix,
570		wsp_OpenUsageType_qname.local);
571		}
572		else
573		{
574	0	type_value = globus_libc_strdup(wsp_OpenUsageType_qname.local);
575		}
576		}
577
578		/* serialize namespaces */
579
580	0	result = globus_soap_message_invoke_ns_callouts(
581		message_handle,
582		element_qname,
583		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_ADD,
584		&options);
585	0	if(result != GLOBUS_SUCCESS)
586		{
587	0	result = GlobusSoapMessageErrorSerializeFailed(
588		result, NULL, element_qname);
589	0	goto exit;
590		}
591
592
593	0	result = globus_soap_message_element_ns_add(
594		message_handle,
595		element_qname->Namespace,
596		&options);
597	0	if(result != GLOBUS_SUCCESS)
598		{
599	0	result = GlobusSoapMessageErrorSerializeFailed(
600		result, NULL, element_qname);
601	0	goto exit;
602		}
603
604	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
605		!globus_soap_message_serialize_is_c14n_subset(message_handle))
606		{
607	0	result = globus_soap_message_attribute_ns_add(
608		message_handle,
609		"http://www.w3.org/2001/XMLSchema-instance",
610		&options);
611	0	if(result != GLOBUS_SUCCESS)
612		{
613	0	result = GlobusSoapMessageErrorSerializeFailed(
614		result, NULL, element_qname);
615	0	goto exit;
616		}
617
618	0	result = globus_soap_message_attribute_ns_add(
619		message_handle,
620		wsp_OpenUsageType_qname.Namespace,
621		&options);
622	0	if(result != GLOBUS_SUCCESS)
623		{
624	0	result = GlobusSoapMessageErrorSerializeFailed(
625		result, NULL, element_qname);
626	0	goto exit;
627		}
628		}
629
630		/* serialize attributes */
631
632	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
633		!globus_soap_message_serialize_is_c14n_subset(message_handle))
634		{
635	0	result = globus_soap_message_serialize_QName_attribute(
636		message_handle,
637		type_attr,
638		&wsp_OpenUsageType_qname);
639	0	if(result != GLOBUS_SUCCESS)
640		{
641	0	result = GlobusSoapMessageErrorSerializeFailed(
642		result, NULL, element_qname);
643	0	goto exit;
644		}
645		}
646
647		}
648
649	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
650		{
651	0	result = globus_soap_message_serialize_element_begin_close(
652		message_handle);
653	0	if(result != GLOBUS_SUCCESS)
654		{
655	0	result = GlobusSoapMessageErrorSerializeFailed(
656		result, NULL, element_qname);
657	0	goto exit;
658		}
659		}
660
661		/* serialize contents of type */
662
663	0	result = xsd_QName_serialize_contents(
664		NULL,
665		(xsd_QName *)instance,
666		message_handle,
667		options);
668	0	if(result != GLOBUS_SUCCESS)
669		{
670	0	result = GlobusSoapMessageErrorSerializeFailed(
671		result, NULL, element_qname);
672	0	goto exit;
673		}
674
675	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
676		{
677		/* add end element */
678	0	result = globus_soap_message_serialize_element_end(
679		message_handle,
680		element_qname,
681		options,
682		&wsp_OpenUsageType_qname);
683	0	if(result != GLOBUS_SUCCESS)
684		{
685	0	result = GlobusSoapMessageErrorSerializeFailed(
686		result, NULL, element_qname);
687	0	goto exit;
688		}
689
690	0	globus_soap_message_element_ns_remove(
691		message_handle,
692		element_qname->Namespace,
693		&options);
694
695		/* remove namespace/prefix mappings for these types */
696
697	0	result = globus_soap_message_invoke_ns_callouts(
698		message_handle,
699		element_qname,
700		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_REMOVE,
701		&options);
702	0	if(result != GLOBUS_SUCCESS)
703		{
704	0	result = GlobusSoapMessageErrorSerializeFailed(
705		result, NULL, element_qname);
706	0	goto exit;
707		}
708
709	0	result = globus_soap_message_invoke_callouts(
710		message_handle,
711		element_qname,
712		GLOBUS_SOAP_MESSAGE_CALLOUT_END);
713	0	if(result != GLOBUS_SUCCESS)
714		{
715	0	result = GlobusSoapMessageErrorSerializeFailed(
716		result, NULL, element_qname);
717		goto exit;
718		}
719		}
720
721		exit:
722
723	0	if(any_attr_keys)
724		{
725	0	globus_list_free(any_attr_keys);
726		}
727
728	0	GlobusSoapMessageDebugExit();
729	0	return result;
730		}
731
732
733
734		globus_result_t
735		wsp_OpenUsageType_deserialize_contents(
736		xsd_QName *                         element_qname, /* ignored */
737		wsp_OpenUsageType * inst,
738		globus_soap_message_handle_t        message_handle,
739		globus_xsd_element_options_t        options)
740	0	{
741	0	globus_result_t                     result = GLOBUS_SUCCESS;
742	0	GlobusFuncName(wsp_OpenUsageType_deserialize_contents);
743	0	GlobusSoapMessageDebugEnter();
744
745	0	result = wsp_OpenUsageType_deserialize(
746		NULL,
747		inst,
748		message_handle,
749		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
750	0	if(result != GLOBUS_SUCCESS)
751		{
752	0	result = GlobusSoapMessageErrorDeserializeFailed(
753		result, element_qname);
754		goto exit;
755		}
756
757		exit:
758
759	0	GlobusSoapMessageDebugExit();
760	0	return result;
761		}
762
763
764
765		globus_result_t
766		wsp_OpenUsageType_deserialize(
767		xsd_QName *                         element_qname,
768		wsp_OpenUsageType * instance,
769		globus_soap_message_handle_t        message_handle,
770		globus_xsd_element_options_t        options)
771	0	{
772	0	globus_result_t                     result = GLOBUS_SUCCESS;
773	0	xsd_QName                           subelement;
774	0	GlobusFuncName(wsp_OpenUsageType_deserialize);
775	0	GlobusSoapMessageDebugEnter();
776
777
778	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
779		{
780	0	result = globus_soap_message_deserialize_element(
781		message_handle, element_qname);
782	0	if(result != GLOBUS_SUCCESS)
783		{
784	0	result = GlobusSoapMessageErrorDeserializeFailed(
785		result, element_qname);
786	0	goto exit;
787		}
788
789	0	result = globus_soap_message_deserialize_element_begin_close(
790		message_handle);
791	0	if(result != GLOBUS_SUCCESS)
792		{
793	0	result = GlobusSoapMessageErrorDeserializeFailed(
794		result, element_qname);
795	0	goto fail_deserialize;
796		}
797		}
798
799	0	result = xsd_QName_deserialize_contents(
800		NULL,
801		(xsd_QName *)instance,
802		message_handle,
803		options);
804	0	if(result != GLOBUS_SUCCESS)
805		{
806	0	result = GlobusSoapMessageErrorDeserializeFailed(
807		result, element_qname);
808	0	goto base_value_destroy;
809		}
810
811	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
812		{
813	0	result = globus_soap_message_deserialize_element_end(
814		message_handle,
815		element_qname);
816	0	if(result != GLOBUS_SUCCESS)
817		{
818	0	result = GlobusSoapMessageErrorDeserializeFailed(
819		result, element_qname);
820		goto fail_deserialize;
821		}
822		}
823
824	0	goto exit;
825
826		fail_deserialize:
827
828	0	xsd_QName_destroy_contents((xsd_QName *)instance);
829		base_value_destroy:
830
831
832		exit:
833
834	0	GlobusSoapMessageDebugExit();
835	0	return result;
836		}
837
838
839
840		globus_result_t
841		wsp_OpenUsageType_deserialize_pointer(
842		xsd_QName *                         element_qname,
843		wsp_OpenUsageType ** ip,
844		globus_soap_message_handle_t        message_handle,
845		globus_xsd_element_options_t        options)
846	0	{
847	0	wsp_OpenUsageType * instance = NULL;
848	0	globus_result_t                     result = GLOBUS_SUCCESS;
849	0	xsd_QName                           subelement;
850	0	GlobusFuncName(wsp_OpenUsageType_deserialize_pointer);
851	0	GlobusSoapMessageDebugEnter();
852
853	0	*ip = NULL;
854
855
856	0	result = globus_soap_message_deserialize_element(
857		message_handle, element_qname);
858	0	if(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
859		GlobusSoapMessageStatusFailedElementCheck(result) ||
860		GlobusSoapMessageStatusFailedWithTextCheck(result))
861		{
862	0	*ip = NULL;
863	0	result = GLOBUS_SUCCESS;
864	0	goto exit;
865		}
866
867	0	if(result != GLOBUS_SUCCESS)
868		{
869	0	result = GlobusSoapMessageErrorDeserializeFailed(
870		result, element_qname);
871	0	goto exit;
872		}
873
874	0	if(globus_soap_message_deserialize_element_is_empty(
875		message_handle))
876		{
877	0	*ip = NULL;
878	0	goto exit;
879		}
880
881	0	result = wsp_OpenUsageType_init(&instance);
882	0	if(result != GLOBUS_SUCCESS)
883		{
884	0	result = GlobusSoapMessageErrorDeserializeFailed(
885		result, element_qname);
886	0	goto exit;
887		}
888
889	0	result = globus_soap_message_deserialize_element_begin_close(
890		message_handle);
891	0	if(result != GLOBUS_SUCCESS)
892		{
893	0	result = GlobusSoapMessageErrorDeserializeFailed(
894		result, element_qname);
895	0	goto exit;
896		}
897
898
899
900	0	result = globus_soap_message_deserialize_element_end(
901		message_handle,
902		element_qname);
903	0	if(result != GLOBUS_SUCCESS)
904		{
905	0	result = GlobusSoapMessageErrorDeserializeFailed(
906		result, element_qname);
907	0	goto exit;
908		}
909
910	0	*ip = instance;
911
912	0	goto exit;
913
914		fail_deserialize:
915
916
917		exit:
918
919	0	GlobusSoapMessageDebugExit();
920	0	return result;
921		}
922
923
924
925		globus_result_t
926		wsp_OpenUsageType_array_init_contents(
927		wsp_OpenUsageType_array * array)
928	0	{
929	0	GlobusFuncName(wsp_OpenUsageType_array_init_contents);
930	0	GlobusSoapMessageDebugEnter();
931
932	0	memset(array, 0, sizeof(wsp_OpenUsageType_array));
933
934	0	GlobusSoapMessageDebugExit();
935	0	return GLOBUS_SUCCESS;
936		}
937
938		globus_result_t
939		wsp_OpenUsageType_array_init(
940		wsp_OpenUsageType_array ** arr)
941	0	{
942	0	wsp_OpenUsageType_array * array;
943	0	globus_result_t                     result;
944	0	GlobusFuncName(wsp_OpenUsageType_array_init);
945	0	GlobusSoapMessageDebugEnter();
946
947	0	array = (wsp_OpenUsageType_array *)
948		globus_malloc(sizeof(wsp_OpenUsageType_array));
949	0	if(!array)
950		{
951	0	result = GlobusSoapMessageErrorOutOfMemory;
952	0	GlobusSoapMessageDebugExit();
953	0	return result;
954		}
955
956	0	result = wsp_OpenUsageType_array_init_contents(array);
957	0	if(result != GLOBUS_SUCCESS)
958		{
959	0	globus_free(array);
960	0	array = NULL;
961
962		}
963
964	0	*arr = array;
965
966	0	GlobusSoapMessageDebugExit();
967	0	return result;
968		}
969
970		void
971		wsp_OpenUsageType_array_destroy_contents(
972		wsp_OpenUsageType_array * array)
973	0	{
974	0	int                                 i = 0;
975	0	GlobusFuncName(wsp_OpenUsageType_array_destroy_contents);
976	0	GlobusSoapMessageDebugEnter();
977
978	0	for(; i < array->length; ++i)
979		{
980	0	wsp_OpenUsageType_destroy_contents(&array->elements[i]);
981		}
982
983	0	if(array->elements)
984		{
985	0	globus_free(array->elements);
986	0	array->elements = NULL;
987		}
988	0	array->length = 0;
989
990	0	GlobusSoapMessageDebugExit();
991		}
992
993		void
994		wsp_OpenUsageType_array_destroy(
995		wsp_OpenUsageType_array * array)
996	0	{
997	0	GlobusFuncName(wsp_OpenUsageType_array_destroy);
998	0	GlobusSoapMessageDebugEnter();
999
1000	0	wsp_OpenUsageType_array_destroy_contents(array);
1001	0	globus_free(array);
1002
1003	0	GlobusSoapMessageDebugExit();
1004		}
1005
1006		globus_result_t
1007		wsp_OpenUsageType_array_copy(
1008		wsp_OpenUsageType_array ** dest_arr,
1009		const wsp_OpenUsageType_array * src_arr)
1010	0	{
1011	0	wsp_OpenUsageType_array * array;
1012	0	globus_result_t                     result;
1013	0	GlobusFuncName(wsp_OpenUsageType_array_copy);
1014	0	GlobusSoapMessageDebugEnter();
1015
1016	0	array = (wsp_OpenUsageType_array *) malloc(
1017		sizeof(wsp_OpenUsageType_array));
1018	0	if(!array)
1019		{
1020	0	result = GlobusSoapMessageErrorOutOfMemory;
1021	0	GlobusSoapMessageDebugExit();
1022	0	return result;
1023		}
1024
1025	0	result = wsp_OpenUsageType_array_copy_contents(array, src_arr);
1026	0	if(result != GLOBUS_SUCCESS)
1027		{
1028	0	globus_free(array);
1029	0	GlobusSoapMessageDebugExit();
1030	0	return result;
1031		}
1032
1033	0	*dest_arr = array;
1034
1035	0	GlobusSoapMessageDebugExit();
1036	0	return GLOBUS_SUCCESS;
1037		}
1038
1039		globus_result_t
1040		wsp_OpenUsageType_array_copy_contents(
1041		wsp_OpenUsageType_array * dest_arr,
1042		const wsp_OpenUsageType_array * src_arr)
1043	0	{
1044	0	int                                 i;
1045	0	globus_result_t                     result = GLOBUS_SUCCESS;
1046	0	GlobusFuncName(wsp_OpenUsageType_array_copy_contents);
1047	0	GlobusSoapMessageDebugEnter();
1048
1049	0	dest_arr->length = src_arr->length;
1050	0	if(dest_arr->length > 0)
1051		{
1052	0	dest_arr->elements = (wsp_OpenUsageType *) malloc(
1053		sizeof(wsp_OpenUsageType) * dest_arr->length);
1054	0	if(!dest_arr->elements)
1055		{
1056	0	result = GlobusSoapMessageErrorOutOfMemory;
1057	0	GlobusSoapMessageDebugExit();
1058	0	return result;
1059		}
1060		}
1061		else
1062		{
1063	0	dest_arr->elements = NULL;
1064		}
1065
1066	0	for(i = 0; i < dest_arr->length; i++)
1067		{
1068	0	result = wsp_OpenUsageType_copy_contents(
1069		&dest_arr->elements[i], &src_arr->elements[i]);
1070	0	if(result != GLOBUS_SUCCESS)
1071		{
1072	0	while(i--)
1073		{
1074	0	wsp_OpenUsageType_destroy_contents(&dest_arr->elements[i]);
1075		}
1076
1077	0	globus_free(dest_arr->elements);
1078	0	dest_arr->elements = NULL;
1079	0	dest_arr->length = 0;
1080	0	break;
1081		}
1082		}
1083
1084	0	GlobusSoapMessageDebugExit();
1085	0	return result;
1086		}
1087
1088		wsp_OpenUsageType *
1089		wsp_OpenUsageType_array_push(
1090		wsp_OpenUsageType_array * array)
1091	0	{
1092	0	GlobusFuncName(wsp_OpenUsageType_array_push);
1093	0	GlobusSoapMessageDebugEnter();
1094
1095	0	array->elements = realloc(array->elements,
1096		sizeof(wsp_OpenUsageType) *
1097		(array->length + 1));
1098	0	memset(&array->elements[array->length], 0, sizeof(wsp_OpenUsageType));
1099	0	array->length++;
1100
1101	0	GlobusSoapMessageDebugExit();
1102	0	return (&array->elements[array->length - 1]);
1103		}
1104
1105		void *
1106		wsp_OpenUsageType_array_push_wrapper(
1107		void * array)
1108	0	{
1109	0	return (void *) wsp_OpenUsageType_array_push((wsp_OpenUsageType_array *) array);
1110		}
1111
1112		globus_result_t
1113		wsp_OpenUsageType_array_serialize(
1114		xsd_QName *                         element_qname,
1115		wsp_OpenUsageType_array * array,
1116		globus_soap_message_handle_t        message,
1117		globus_xsd_element_options_t        options)
1118	0	{
1119	0	globus_result_t                     result = GLOBUS_SUCCESS;
1120	0	int                                 i = 0;
1121	0	GlobusFuncName(wsp_OpenUsageType_array_serialize);
1122	0	GlobusSoapMessageDebugEnter();
1123
1124	0	for(; i < array->length; ++i)
1125		{
1126	0	result = wsp_OpenUsageType_serialize(
1127		element_qname,
1128		&array->elements[i],
1129		message,
1130		options);
1131	0	if(result != GLOBUS_SUCCESS)
1132		{
1133	0	goto exit;
1134		}
1135		}
1136
1137		exit:
1138
1139	0	GlobusSoapMessageDebugExit();
1140	0	return result;
1141		}
1142
1143		globus_result_t
1144		wsp_OpenUsageType_array_deserialize(
1145		xsd_QName *                         element_qname,
1146		wsp_OpenUsageType_array * array,
1147		globus_soap_message_handle_t        message,
1148		globus_xsd_element_options_t        options)
1149	0	{
1150	0	globus_result_t                     result = GLOBUS_SUCCESS;
1151	0	int                                 i = 0;
1152	0	int                                 pre_length;
1153	0	GlobusFuncName(wsp_OpenUsageType_array_deserialize);
1154	0	GlobusSoapMessageDebugEnter();
1155
1156	0	pre_length = array->length;
1157
1158	0	for(i = 0; i < pre_length; ++i)
1159		{
1160	0	result = wsp_OpenUsageType_deserialize(
1161		element_qname,
1162		&array->elements[i],
1163		message,
1164		options);
1165	0	if(result != GLOBUS_SUCCESS)
1166		{
1167	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1168		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1169		GlobusSoapMessageStatusFailedWithTextCheck(result))
1170		{
1171	0	result = GLOBUS_SUCCESS;
1172	0	break;
1173		}
1174
1175	0	result = GlobusSoapMessageErrorDeserializeFailed(
1176		result, element_qname);
1177	0	goto exit;
1178		}
1179		}
1180
1181	0	while(result == GLOBUS_SUCCESS)
1182		{
1183	0	wsp_OpenUsageType                  next;
1184	0	memset(&next, 0, sizeof(wsp_OpenUsageType));
1185
1186	0	result = wsp_OpenUsageType_deserialize(
1187		element_qname,
1188		&next,
1189		message,
1190		options);
1191	0	if(result != GLOBUS_SUCCESS)
1192		{
1193	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1194		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1195		GlobusSoapMessageStatusFailedWithTextCheck(result))
1196		{
1197	0	result = GLOBUS_SUCCESS;
1198	0	break;
1199		}
1200
1201	0	result = GlobusSoapMessageErrorDeserializeFailed(
1202		result, element_qname);
1203	0	goto exit;
1204		}
1205
1206	0	array->elements = realloc(
1207		array->elements,
1208		(array->length + 1) * sizeof(wsp_OpenUsageType));
1209	0	if(!array->elements)
1210		{
1211	0	result = GlobusSoapMessageErrorOutOfMemory;
1212	0	goto exit;
1213		}
1214	0	array->elements[array->length] = next;
1215	0	array->length++;
1216	0	++i;
1217		}
1218
1219		exit:
1220
1221	0	if(result != GLOBUS_SUCCESS)
1222		{
1223	0	int                             di = 0;
1224	0	for(; di < i; ++di)
1225		{
1226	0	wsp_OpenUsageType_destroy_contents(
1227		&array->elements[di]);
1228	0	memset(&array->elements[di], 0, sizeof(wsp_OpenUsageType));
1229		}
1230		}
1231
1232	0	GlobusSoapMessageDebugExit();
1233	0	return result;
1234		}
1235
1236
1237		globus_result_t
1238		wsp_OpenUsageType_serialize_attribute(
1239		xsd_QName *                         attr_qname,
1240		wsp_OpenUsageType * val,
1241		globus_soap_message_handle_t        handle,
1242		globus_xsd_element_options_t        options)
1243	0	{
1244	0	globus_result_t                     result = GLOBUS_SUCCESS;
1245	0	GlobusFuncName(wsp_OpenUsageType_serialize_attribute);
1246	0	GlobusSoapMessageDebugEnter();
1247
1248
1249	0	result = xsd_QName_serialize_attribute(
1250		attr_qname, (xsd_QName *)val, handle, options);
1251	0	if(result != GLOBUS_SUCCESS)
1252		{
1253	0	result = GlobusSoapMessageErrorSerializeFailed(
1254		result, NULL, attr_qname);
1255		goto exit;
1256		}
1257
1258		exit:
1259
1260	0	GlobusSoapMessageDebugExit();
1261	0	return result;
1262		}
1263
1264		globus_result_t
1265		wsp_OpenUsageType_deserialize_attribute(
1266		xsd_QName *                         attr_qname,
1267		wsp_OpenUsageType * instance,
1268		globus_soap_message_handle_t        message,
1269		globus_xsd_element_options_t        options)
1270	0	{
1271	0	globus_result_t                     result = GLOBUS_SUCCESS;
1272	0	GlobusFuncName(wsp_OpenUsageType_deserialize_attribute);
1273	0	GlobusSoapMessageDebugEnter();
1274
1275
1276	0	result = xsd_QName_deserialize_attribute(
1277		attr_qname, (xsd_QName *)instance, message, options);
1278
1279	0	if(result != GLOBUS_SUCCESS)
1280		{
1281	0	result = GlobusSoapMessageErrorDeserializeFailed(
1282		result, attr_qname);
1283		goto exit;
1284		}
1285
1286		exit:
1287
1288	0	GlobusSoapMessageDebugExit();
1289	0	return result;
1290		}
1291
1292		globus_result_t
1293		wsp_OpenUsageType_deserialize_attribute_pointer(
1294		xsd_QName *                         attr_qname,
1295		wsp_OpenUsageType ** instance,
1296		globus_soap_message_handle_t        message,
1297		globus_xsd_element_options_t        options)
1298	0	{
1299	0	globus_result_t                     result = GLOBUS_SUCCESS;
1300	0	GlobusFuncName(wsp_OpenUsageType_deserialize_attribute_pointer);
1301	0	GlobusSoapMessageDebugEnter();
1302
1303
1304	0	result = xsd_QName_deserialize_attribute_pointer(
1305		attr_qname, (xsd_QName **)instance, message, options);
1306
1307	0	if(result != GLOBUS_SUCCESS)
1308		{
1309	0	result = GlobusSoapMessageErrorDeserializeFailed(
1310		result, attr_qname);
1311		goto exit;
1312		}
1313
1314		exit:
1315
1316	0	GlobusSoapMessageDebugExit();
1317	0	return result;