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