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