1		/*
2		* Copyright 1999-2006 University of Chicago
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17
18		/*
19		* This file is automatically generated by the Globus WSDLtoC converter
20		*/
21
22		#include "xsd_QName.h"
23		#include "globus_soap_message.h"
24		#include "globus_xsd_type_info.h"
25		#include "rptest_TestStepType.h"
26
27		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
28		xsd_QName rptest_TestStepType_qname =
29		{
30		RPTEST_TESTSTEPTYPE_NS,
31		RPTEST_TESTSTEPTYPE_LOCAL
32		};
33		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
34
35		globus_result_t
36		rptest_TestStepType_serialize_wrapper(
37		const xsd_QName *                   element_qname,
38		const void *                        instance,
39		globus_soap_message_handle_t        message_handle,
40		globus_xsd_element_options_t        options)
41	0	{
42	0	return rptest_TestStepType_serialize(
43		element_qname,
44		(const rptest_TestStepType *) instance,
45		message_handle, options);
46		}
47
48		globus_result_t
49		rptest_TestStepType_deserialize_pointer_wrapper(
50		const xsd_QName *                   element_qname,
51		void **                             ip,
52		globus_soap_message_handle_t        message_handle,
53		globus_xsd_element_options_t        options)
54	260	{
55	260	return rptest_TestStepType_deserialize_pointer(
56		element_qname,
57		(rptest_TestStepType **) ip,
58		message_handle, options);
59		}
60
61		globus_result_t
62		rptest_TestStepType_init_wrapper(void **object)
63	0	{
64	0	return rptest_TestStepType_init(
65		(rptest_TestStepType **) object);
66		}
67
68		void
69		rptest_TestStepType_destroy_wrapper(
70		void *                          object)
71	260	{
72	260	rptest_TestStepType_destroy(
73		(rptest_TestStepType *) object);
74		}
75
76		globus_result_t
77		rptest_TestStepType_copy_wrapper(
78		void **                         dest_obj,
79		const void *                    src_obj)
80	0	{
81	0	return rptest_TestStepType_copy(
82		(rptest_TestStepType **) dest_obj,
83		(rptest_TestStepType *) src_obj);
84		}
85
86		globus_result_t
87		rptest_TestStepType_init_contents_wrapper(void *object)
88	0	{
89	0	return rptest_TestStepType_init_contents(
90		(rptest_TestStepType *) object);
91		}
92
93		void
94		rptest_TestStepType_destroy_contents_wrapper(
95		void *                          object)
96	260	{
97	260	rptest_TestStepType_destroy_contents(
98		(rptest_TestStepType *) object);
99		}
100
101		globus_result_t
102		rptest_TestStepType_copy_contents_wrapper(
103		void *                          dest_obj,
104		const void *                    src_obj)
105	260	{
106	260	return rptest_TestStepType_copy_contents(
107		(rptest_TestStepType *) dest_obj,
108		(const rptest_TestStepType *) src_obj);
109		}
110
111		globus_result_t
112		rptest_TestStepType_serialize_contents_wrapper(
113		const xsd_QName *                   element_qname,
114		const void *                        instance,
115		globus_soap_message_handle_t        message_handle,
116		globus_xsd_element_options_t        options)
117	0	{
118	0	return rptest_TestStepType_serialize_contents(
119		element_qname,
120		(rptest_TestStepType *) instance,
121		message_handle, options);
122		}
123
124		globus_result_t
125		rptest_TestStepType_deserialize_contents_wrapper(
126		const xsd_QName *                   element_qname,
127		void **                             instance,
128		globus_soap_message_handle_t        message_handle,
129		globus_xsd_element_options_t        options)
130	0	{
131	0	globus_result_t                     result;
132	0	GlobusFuncName(rptest_TestStepType_deserialize_contents_wrapper);
133	0	GlobusSoapMessageDebugEnter();
134
135	0	if(!*instance)
136		{
137	0	result = rptest_TestStepType_init(
138		(rptest_TestStepType **)instance);
139	0	if(result != GLOBUS_SUCCESS)
140		{
141	0	goto error;
142		}
143		}
144
145	0	result = rptest_TestStepType_deserialize_contents(
146		element_qname,
147		*(rptest_TestStepType **)instance,
148		message_handle, options);
149		error:
150	0	GlobusSoapMessageDebugExit();
151	0	return result;
152		}
153
154		globus_result_t
155		rptest_TestStepType_array_serialize_wrapper(
156		const xsd_QName *               element,
157		const void *                    instance,
158		globus_soap_message_handle_t    message,
159		globus_xsd_element_options_t    options)
160	0	{
161	0	return rptest_TestStepType_array_serialize(
162		element,
163		(rptest_TestStepType_array *) instance,
164		message, options);
165		}
166
167		globus_result_t
168		rptest_TestStepType_array_deserialize_wrapper(
169		const xsd_QName *                   element_qname,
170		void **                             inst,
171		globus_soap_message_handle_t        message,
172		globus_xsd_element_options_t        options)
173	0	{
174	0	if(!*inst)
175		{
176	0	globus_result_t                 result;
177
178	0	result = rptest_TestStepType_array_init(
179		(rptest_TestStepType_array **)inst);
180	0	if(result != GLOBUS_SUCCESS)
181		{
182	0	return result;
183		}
184		}
185
186	0	return rptest_TestStepType_array_deserialize(
187		element_qname,
188		*(rptest_TestStepType_array **) inst,
189		message, options);
190		}
191
192		globus_result_t
193		rptest_TestStepType_array_init_wrapper(
194		void **                             arr)
195	0	{
196	0	return rptest_TestStepType_array_init(
197		(rptest_TestStepType_array **) arr);
198		}
199
200		void
201		rptest_TestStepType_array_destroy_wrapper(
202		void *                              arr)
203	0	{
204	0	rptest_TestStepType_array_destroy(
205		(rptest_TestStepType_array *) arr);
206		}
207
208		globus_result_t
209		rptest_TestStepType_array_copy_wrapper(
210		void **                             dest_arr,
211		const void *                        src_arr)
212	0	{
213	0	return rptest_TestStepType_array_copy(
214		(rptest_TestStepType_array **) dest_arr,
215		(const rptest_TestStepType_array *) src_arr);
216		}
217
218		globus_result_t
219		rptest_TestStepType_array_init_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	return rptest_TestStepType_array_init_contents(
223		(rptest_TestStepType_array *) arr);
224		}
225
226		void
227		rptest_TestStepType_array_destroy_contents_wrapper(
228		void *                              arr)
229	0	{
230	0	rptest_TestStepType_array_destroy_contents(
231		(rptest_TestStepType_array *) arr);
232		}
233
234		globus_result_t
235		rptest_TestStepType_array_copy_contents_wrapper(
236		void *                              dest_arr,
237		const void *                        src_arr)
238	0	{
239	0	return rptest_TestStepType_array_copy_contents(
240		(rptest_TestStepType_array *) dest_arr,
241		(const rptest_TestStepType_array *) src_arr);
242		}
243
244		struct globus_xsd_type_info_s rptest_TestStepType_contents_info =
245		{
246		&rptest_TestStepType_qname,
247		rptest_TestStepType_serialize_contents_wrapper,
248		rptest_TestStepType_deserialize_contents_wrapper,
249		rptest_TestStepType_init_wrapper,
250		rptest_TestStepType_destroy_wrapper,
251		rptest_TestStepType_copy_wrapper,
252		rptest_TestStepType_init_contents_wrapper,
253		rptest_TestStepType_destroy_contents_wrapper,
254		rptest_TestStepType_copy_contents_wrapper,
255		sizeof(rptest_TestStepType),
256		NULL,
257		NULL,
258		NULL
259		};
260
261		struct globus_xsd_type_info_s rptest_TestStepType_array_info =
262		{
263		&rptest_TestStepType_qname,
264		rptest_TestStepType_array_serialize_wrapper,
265		rptest_TestStepType_array_deserialize_wrapper,
266		rptest_TestStepType_array_init_wrapper,
267		rptest_TestStepType_array_destroy_wrapper,
268		rptest_TestStepType_array_copy_wrapper,
269		rptest_TestStepType_array_init_contents_wrapper,
270		rptest_TestStepType_array_destroy_contents_wrapper,
271		rptest_TestStepType_array_copy_contents_wrapper,
272		sizeof(rptest_TestStepType),
273		rptest_TestStepType_array_push_wrapper,
274		NULL,
275		NULL
276		};
277
278		struct globus_xsd_type_info_s rptest_TestStepType_info =
279		{
280		&rptest_TestStepType_qname,
281		rptest_TestStepType_serialize_wrapper,
282		rptest_TestStepType_deserialize_pointer_wrapper,
283		rptest_TestStepType_init_wrapper,
284		rptest_TestStepType_destroy_wrapper,
285		rptest_TestStepType_copy_wrapper,
286		rptest_TestStepType_init_contents_wrapper,
287		rptest_TestStepType_destroy_contents_wrapper,
288		rptest_TestStepType_copy_contents_wrapper,
289		sizeof(rptest_TestStepType),
290		NULL,
291		&rptest_TestStepType_contents_info,
292		&rptest_TestStepType_array_info
293		};
294
295		globus_result_t
296		rptest_TestStepType_init_contents(
297		rptest_TestStepType * instance)
298	0	{
299	0	globus_result_t                     result = GLOBUS_SUCCESS;
300	0	GlobusFuncName(rptest_TestStepType_init_contents);
301	0	GlobusSoapMessageDebugEnter();
302
303	0	memset(instance, 0, sizeof(rptest_TestStepType));
304
305	0	GlobusSoapMessageDebugExit();
306	0	return result;
307		}
308
309		globus_result_t
310		rptest_TestStepType_init(
311		rptest_TestStepType ** object)
312	260	{
313	260	rptest_TestStepType * instance;
314	260	globus_result_t                     result = GLOBUS_SUCCESS;
315	260	GlobusFuncName(rptest_TestStepType_init);
316	260	GlobusSoapMessageDebugEnter();
317
318	260	instance = globus_malloc(sizeof(rptest_TestStepType));
319	260	if(!instance)
320		{
321	0	result = GlobusSoapMessageErrorOutOfMemory;
322	0	goto exit;
323		}
324
325	260	memset(instance, 0, sizeof(rptest_TestStepType));
326
327	260	*object = instance;
328
329		exit:
330	260	GlobusSoapMessageDebugExit();
331	260	return result;
332		}
333
334		void
335		rptest_TestStepType_destroy(
336		rptest_TestStepType * instance)
337	260	{
338	260	GlobusFuncName(rptest_TestStepType_destroy);
339	260	GlobusSoapMessageDebugEnter();
340
341	260	if(!instance)
342		{
343	0	goto exit;
344		}
345
346	260	rptest_TestStepType_destroy_contents(instance);
347	260	globus_free(instance);
348
349		exit:
350
351	260	GlobusSoapMessageDebugExit();
352		}
353
354
355		void
356		rptest_TestStepType_destroy_contents(
357		rptest_TestStepType * instance)
358	520	{
359	520	GlobusFuncName(rptest_TestStepType_destroy_contents);
360	520	GlobusSoapMessageDebugEnter();
361
362	520	if(instance)
363		{
364
365
366	520	rptest_TestStepType_choice_destroy_contents(
367		&instance->choice_value);
368
369	520	if(instance->_name)
370		{
371	520	xsd_string_destroy(
372		instance->_name);
373	520	instance->_name = NULL;
374		}
375
376		}
377
378	520	GlobusSoapMessageDebugExit();
379		}
380
381
382		globus_result_t
383		rptest_TestStepType_copy(
384		rptest_TestStepType ** dest_obj,
385		const rptest_TestStepType * src_obj)
386	0	{
387	0	globus_result_t                     result = GLOBUS_SUCCESS;
388	0	rptest_TestStepType * instance;
389	0	GlobusFuncName(rptest_TestStepType_copy);
390
391	0	GlobusSoapMessageDebugEnter();
392
393	0	instance = calloc(1, sizeof(rptest_TestStepType));
394	0	if (instance == NULL)
395		{
396	0	GlobusSoapMessageDebugExit();
397	0	return GlobusSoapMessageErrorOutOfMemory;
398		}
399
400	0	result = rptest_TestStepType_copy_contents(instance, src_obj);
401	0	if(result != GLOBUS_SUCCESS)
402		{
403	0	globus_free(instance);
404	0	GlobusSoapMessageDebugExit();
405	0	return GlobusSoapMessageErrorOutOfMemory;
406		}
407
408	0	*dest_obj = instance;
409	0	GlobusSoapMessageDebugExit();
410	0	return result;
411		}
412
413		globus_result_t
414		rptest_TestStepType_copy_contents(
415		rptest_TestStepType * instance,
416		const rptest_TestStepType * src_obj)
417	260	{
418	260	globus_result_t                     result = GLOBUS_SUCCESS;
419	260	GlobusFuncName(rptest_TestStepType_copy_contents);
420
421	260	GlobusSoapMessageDebugEnter();
422
423	260	if(src_obj->_name)
424		{
425	260	result = xsd_string_copy(
426		&instance->_name,
427		src_obj->_name);
428	260	if(result != GLOBUS_SUCCESS)
429		{
430	0	result = GlobusSoapMessageErrorCopyFailed(
431		result, NULL, &xsd_string_qname);
432	0	goto _name_destroy;
433		}
434		}
435		else
436		{
437	0	instance->_name = NULL;
438		}
439
440	260	result = rptest_TestStepType_choice_copy_contents(
441		&instance->choice_value,
442		&src_obj->choice_value);
443	260	if(result != GLOBUS_SUCCESS)
444		{
445	0	result = GlobusSoapMessageErrorCopyFailed(
446		result, NULL, &rptest_TestStepType_choice_qname);
447	0	goto choice_value_destroy;
448		}
449
450	0	goto exit;
451
452		fail_deserialize:
453
454		_name_destroy:
455
456	0	if(instance->_name)
457		{
458	0	xsd_string_destroy(
459		instance->_name);
460	0	instance->_name = NULL;
461		}
462	0	rptest_TestStepType_choice_destroy_contents(
463		&instance->choice_value);
464
465		choice_value_destroy:
466
467
468		exit:
469
470	260	GlobusSoapMessageDebugExit();
471	260	return result;
472		}
473
474
475
476		globus_result_t
477		rptest_TestStepType_serialize_contents(
478		const xsd_QName *                   element_qname, /* ignored */
479		const rptest_TestStepType *              inst,
480		globus_soap_message_handle_t        message_handle,
481		globus_xsd_element_options_t        options)
482	0	{
483	0	globus_result_t                     result = GLOBUS_SUCCESS;
484	0	GlobusFuncName(rptest_TestStepType_serialize_contents);
485	0	GlobusSoapMessageDebugEnter();
486
487	0	result = rptest_TestStepType_serialize(
488		NULL,
489		inst,
490		message_handle,
491		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
492	0	if(result != GLOBUS_SUCCESS)
493		{
494	0	result = GlobusSoapMessageErrorSerializeFailed(
495		result, NULL, element_qname);
496		goto exit;
497		}
498
499		exit:
500
501	0	GlobusSoapMessageDebugExit();
502	0	return result;
503		}
504
505
506
507		globus_result_t
508		rptest_TestStepType_serialize(
509		const xsd_QName *                   element_qname,
510		const rptest_TestStepType *              instance,
511		globus_soap_message_handle_t        message_handle,
512		globus_xsd_element_options_t        options)
513	0	{
514	0	globus_result_t                     result = GLOBUS_SUCCESS;
515	0	xsd_QName                           subelement;
516	0	globus_list_t *                     any_attr_keys = NULL;
517	0	globus_list_t *                     any_attr_keys_iterator = NULL;
518	0	xsd_QName *                         type_attr = NULL;
519
520	0	char *                              prefix = NULL;
521	0	int                                 prefix_created;
522	0	int                                 define_prefix = 0;
523	0	int                                 save_options = options;
524
525	0	GlobusFuncName(rptest_TestStepType_serialize);
526	0	GlobusSoapMessageDebugEnter();
527
528
529	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
530		{
531		/* serialize rptest_TestStepType element */
532	0	result = globus_soap_message_element_ns_set(
533		message_handle,
534		element_qname,
535		element_qname->Namespace,
536		&options);
537	0	if(result != GLOBUS_SUCCESS)
538		{
539	0	result = GlobusSoapMessageErrorSerializeFailed(
540		result, NULL, element_qname);
541	0	goto exit;
542		}
543
544	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
545		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
546		{
547	0	result = globus_soap_message_attribute_ns_set(
548		message_handle,
549		element_qname,
550		"http://www.w3.org/2001/XMLSchema-instance",
551		&options);
552	0	if(result != GLOBUS_SUCCESS)
553		{
554	0	result = GlobusSoapMessageErrorSerializeFailed(
555		result, NULL, element_qname);
556	0	goto exit;
557		}
558		}
559
560	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
561		!globus_soap_message_serialize_is_c14n_subset(message_handle))
562		{
563
564	0	result = globus_soap_message_attribute_ns_set(
565		message_handle,
566		element_qname,
567		rptest_TestStepType_qname.Namespace,
568		&options);
569	0	if(result != GLOBUS_SUCCESS)
570		{
571	0	result = GlobusSoapMessageErrorSerializeFailed(
572		result, NULL, element_qname);
573	0	goto exit;
574		}
575		}
576
577	0	if(instance->_name)
578		{
579
580	0	result = globus_soap_message_attribute_ns_set(
581		message_handle,
582		element_qname,
583		NULL,
584		&options);
585
586	0	if(result != GLOBUS_SUCCESS)
587		{
588	0	xsd_QName               error_qname;
589	0	error_qname.local = prefix;
590	0	error_qname.Namespace = "";
591	0	result = GlobusSoapMessageErrorSerializeFailed(result,
592		NULL,
593		&error_qname);
594	0	goto exit;
595		}
596
597
598		}
599
600	0	result = globus_soap_message_serialize_element(
601		message_handle,
602		element_qname,
603		options,
604		&rptest_TestStepType_qname);
605	0	if(result != GLOBUS_SUCCESS)
606		{
607	0	result = GlobusSoapMessageErrorSerializeFailed(
608		result, NULL, element_qname);
609	0	goto exit;
610		}
611
612	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
613		!globus_soap_message_serialize_is_c14n_subset(message_handle))
614		{
615	0	xsd_QName_init(&type_attr);
616
617	0	type_attr->local = globus_libc_strdup("type");
618	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
619		}
620
621
622		/* serialize namespaces */
623	0	result = globus_soap_message_element_ns_add(
624		message_handle,
625		element_qname,
626		element_qname->Namespace,
627		&options);
628	0	if(result != GLOBUS_SUCCESS)
629		{
630	0	result = GlobusSoapMessageErrorSerializeFailed(
631		result, NULL, element_qname);
632	0	goto exit;
633		}
634
635	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
636		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
637		{
638	0	result = globus_soap_message_attribute_ns_add(
639		message_handle,
640		element_qname,
641		"http://www.w3.org/2001/XMLSchema-instance",
642		&options);
643	0	if(result != GLOBUS_SUCCESS)
644		{
645	0	result = GlobusSoapMessageErrorSerializeFailed(
646		result, NULL, element_qname);
647	0	goto exit;
648		}
649		}
650	0	if ((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
651		!globus_soap_message_serialize_is_c14n_subset(message_handle))
652		{
653
654	0	result = globus_soap_message_attribute_ns_add(
655		message_handle,
656		element_qname,
657		rptest_TestStepType_qname.Namespace,
658		&options);
659	0	if(result != GLOBUS_SUCCESS)
660		{
661	0	result = GlobusSoapMessageErrorSerializeFailed(
662		result, NULL, element_qname);
663	0	goto exit;
664		}
665		}
666
667	0	if(instance->_name)
668		{
669
670	0	result = globus_soap_message_attribute_ns_add(
671		message_handle,
672		element_qname,
673		NULL,
674		&options);
675
676	0	if(result != GLOBUS_SUCCESS)
677		{
678	0	xsd_QName               error_qname;
679	0	error_qname.local = prefix;
680	0	error_qname.Namespace = "";
681	0	result = GlobusSoapMessageErrorSerializeFailed(result,
682		NULL,
683		&error_qname);
684	0	goto exit;
685		}
686
687
688		}
689
690		/* serialize attributes */
691
692	0	subelement.Namespace = "";
693	0	subelement.local = "name";
694
695	0	if(instance->_name)
696		{
697
698	0	result = xsd_string_serialize_attribute(
699		&subelement,
700		instance->_name,
701		message_handle,
702		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
703	0	if(result != GLOBUS_SUCCESS)
704		{
705	0	result = GlobusSoapMessageErrorSerializeFailed(result,
706		NULL,
707		element_qname);
708	0	goto exit;
709		}
710
711		}
712
713	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
714		!globus_soap_message_serialize_is_c14n_subset(message_handle))
715		{
716	0	result = globus_soap_message_serialize_QName_attribute(
717		message_handle,
718		type_attr,
719		&rptest_TestStepType_qname);
720	0	if(result != GLOBUS_SUCCESS)
721		{
722	0	result = GlobusSoapMessageErrorSerializeFailed(
723		result, NULL, element_qname);
724	0	goto exit;
725		}
726		}
727
728
729		}
730
731	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
732		{
733	0	result = globus_soap_message_serialize_element_begin_close(
734		message_handle, element_qname);
735	0	if(result != GLOBUS_SUCCESS)
736		{
737	0	result = GlobusSoapMessageErrorSerializeFailed(
738		result, NULL, element_qname);
739	0	goto exit;
740		}
741		}
742	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
743
744
745		/* serialize contents of type */
746
747	0	subelement.local = "choice_value";
748	0	subelement.Namespace = NULL;
749
750	0	result = rptest_TestStepType_choice_serialize(
751		&subelement,
752		&instance->choice_value,
753		message_handle,
754		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
755	0	if(result != GLOBUS_SUCCESS)
756		{
757	0	result = GlobusSoapMessageErrorSerializeFailed(
758		result, NULL, &rptest_TestStepType_choice_qname);
759	0	goto exit;
760		}
761
762	0	options = save_options;
763
764	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
765		{
766		/* add end element */
767	0	result = globus_soap_message_serialize_element_end(
768		message_handle,
769		element_qname,
770		options,
771		&rptest_TestStepType_qname);
772	0	if(result != GLOBUS_SUCCESS)
773		{
774	0	result = GlobusSoapMessageErrorSerializeFailed(
775		result, NULL, element_qname);
776	0	goto exit;
777		}
778
779	0	globus_soap_message_element_ns_remove(
780		message_handle,
781		element_qname->Namespace,
782		&options);
783
784		/* remove namespace/prefix mappings for these types */
785
786	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
787		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
788		{
789	0	globus_soap_message_attribute_ns_remove(
790		message_handle,
791		"http://www.w3.org/2001/XMLSchema-instance",
792		&options);
793		}
794	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
795		!globus_soap_message_serialize_is_c14n_subset(message_handle))
796		{
797	0	globus_soap_message_attribute_ns_remove(
798		message_handle,
799		rptest_TestStepType_qname.Namespace,
800		&options);
801		}
802
803	0	if(instance->_name)
804		{
805
806	0	globus_soap_message_attribute_ns_remove(
807		message_handle,
808		NULL,
809		&options);
810
811		}
812
813		}
814
815		exit:
816	0	if (type_attr)
817		{
818	0	xsd_QName_destroy(type_attr);
819		}
820
821
822	0	if(any_attr_keys)
823		{
824	0	globus_list_free(any_attr_keys);
825		}
826
827	0	GlobusSoapMessageDebugExit();
828	0	return result;
829		}
830
831
832
833		globus_result_t
834		rptest_TestStepType_deserialize_contents(
835		const xsd_QName *                   element_qname, /* ignored */
836		rptest_TestStepType *                    inst,
837		globus_soap_message_handle_t        message_handle,
838		globus_xsd_element_options_t        options)
839	0	{
840	0	globus_result_t                     result = GLOBUS_SUCCESS;
841	0	GlobusFuncName(rptest_TestStepType_deserialize_contents);
842	0	GlobusSoapMessageDebugEnter();
843
844	0	result = rptest_TestStepType_deserialize(
845		NULL,
846		inst,
847		message_handle,
848		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
849	0	if(result != GLOBUS_SUCCESS)
850		{
851	0	result = GlobusSoapMessageErrorDeserializeFailed(
852		result, element_qname);
853		goto exit;
854		}
855
856		exit:
857
858	0	GlobusSoapMessageDebugExit();
859	0	return result;
860		}
861
862
863
864		globus_result_t
865		rptest_TestStepType_deserialize(
866		const xsd_QName *                   element_qname,
867		rptest_TestStepType *                    instance,
868		globus_soap_message_handle_t        message_handle,
869		globus_xsd_element_options_t        options)
870	260	{
871	260	globus_result_t                     result = GLOBUS_SUCCESS;
872	260	xsd_QName                           subelement;
873	260	GlobusFuncName(rptest_TestStepType_deserialize);
874	260	GlobusSoapMessageDebugEnter();
875
876
877	260	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
878		{
879	0	result = globus_soap_message_deserialize_element(
880		message_handle, element_qname);
881	0	if(result != GLOBUS_SUCCESS)
882		{
883	0	result = GlobusSoapMessageErrorDeserializeFailed(
884		result, element_qname);
885	0	goto exit;
886		}
887
888	0	subelement.Namespace = "";
889	0	subelement.local = "name";
890
891	0	result = xsd_string_deserialize_attribute_pointer(
892		&subelement,
893		&instance->_name,
894		message_handle,
895		0);
896	0	if(result != GLOBUS_SUCCESS)
897		{
898	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
899	0	goto _name_destroy;
900		}
901
902
903
904	0	result = globus_soap_message_deserialize_element_begin_close(
905		message_handle);
906	0	if(result != GLOBUS_SUCCESS)
907		{
908	0	result = GlobusSoapMessageErrorDeserializeFailed(
909		result, element_qname);
910	0	goto fail_deserialize;
911		}
912		}
913
914	260	subelement.local = "choice_value";
915	260	subelement.Namespace = NULL;
916
917	260	result = rptest_TestStepType_choice_deserialize(
918		&subelement,
919		&instance->choice_value,
920		message_handle,
921		0);
922	260	if(result != GLOBUS_SUCCESS)
923		{
924	0	result = GlobusSoapMessageErrorDeserializeFailed(
925		result,
926		&rptest_TestStepType_choice_qname);
927	0	goto choice_value_destroy;
928		}
929
930	260	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
931		{
932	0	result = globus_soap_message_deserialize_element_end(
933		message_handle,
934		element_qname);
935	0	if(result != GLOBUS_SUCCESS)
936		{
937	0	result = GlobusSoapMessageErrorDeserializeFailed(
938		result, element_qname);
939		goto fail_deserialize;
940		}
941		}
942
943	0	goto exit;
944
945		fail_deserialize:
946
947		_name_destroy:
948		/* output_fail_destroy_attribute() */
949
950	0	if(instance->_name)
951		{
952	0	xsd_string_destroy(
953		instance->_name);
954	0	instance->_name = NULL;
955		}
956	0	rptest_TestStepType_choice_destroy_contents(
957		&instance->choice_value);
958
959		choice_value_destroy:
960
961
962		exit:
963
964	260	GlobusSoapMessageDebugExit();
965	260	return result;
966		}
967
968
969
970		globus_result_t
971		rptest_TestStepType_deserialize_pointer(
972		const xsd_QName *                   element_qname,
973		rptest_TestStepType **                   ip,
974		globus_soap_message_handle_t        message_handle,
975		globus_xsd_element_options_t        options)
976	260	{
977	260	rptest_TestStepType * instance = NULL;
978	260	globus_result_t                     result = GLOBUS_SUCCESS;
979	260	xsd_QName                           subelement;
980	260	int                                 found_attrs = 0;
981	260	int                                 empty_element = 0;
982	260	GlobusFuncName(rptest_TestStepType_deserialize_pointer);
983	260	GlobusSoapMessageDebugEnter();
984
985	260	*ip = NULL;
986
987	260	result = globus_soap_message_deserialize_element(
988		message_handle, element_qname);
989	260	if(result != GLOBUS_SUCCESS &&
990		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
991		GlobusSoapMessageStatusFailedElementCheck(result) ||
992		GlobusSoapMessageStatusFailedWithTextCheck(result)))
993		{
994	0	result = GLOBUS_SUCCESS;
995	0	goto exit;
996		}
997
998	260	if(result != GLOBUS_SUCCESS)
999		{
1000	0	result = GlobusSoapMessageErrorDeserializeFailed(
1001		result, element_qname);
1002	0	goto exit;
1003		}
1004
1005	260	if(globus_soap_message_deserialize_element_is_empty(
1006		message_handle))
1007		{
1008	0	empty_element = 1;
1009		}
1010
1011	260	result = rptest_TestStepType_init(&instance);
1012	260	if(result != GLOBUS_SUCCESS)
1013		{
1014	0	result = GlobusSoapMessageErrorDeserializeFailed(
1015		result, element_qname);
1016	0	goto exit;
1017		}
1018
1019
1020	260	subelement.Namespace = "";
1021	260	subelement.local = "name";
1022
1023	260	result = xsd_string_deserialize_attribute_pointer(
1024		&subelement,
1025		&instance->_name,
1026		message_handle,
1027		0);
1028	260	if(result != GLOBUS_SUCCESS)
1029		{
1030	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1031	0	goto _name_destroy;
1032		}
1033
1034
1035	260	if(instance->_name)
1036		{
1037	260	found_attrs++;
1038		}
1039
1040	260	if(found_attrs == 0 &&
1041		globus_soap_message_deserialize_element_is_nil(message_handle))
1042		{
1043	0	rptest_TestStepType_destroy(instance);
1044
1045	0	result = globus_soap_message_deserialize_element_end(
1046		message_handle,
1047		element_qname);
1048	0	if(result != GLOBUS_SUCCESS)
1049		{
1050	0	result = GlobusSoapMessageErrorDeserializeFailed(
1051		result, element_qname);
1052	0	goto exit;
1053		}
1054
1055	0	*ip = NULL;
1056	0	globus_object_free(globus_error_get(result));
1057	0	result = GLOBUS_SUCCESS;
1058	0	goto exit;
1059		}
1060
1061
1062	260	if(empty_element)
1063		{
1064	0	result = globus_soap_message_deserialize_element_end(
1065		message_handle,
1066		element_qname);
1067	0	if(result != GLOBUS_SUCCESS)
1068		{
1069	0	result = GlobusSoapMessageErrorDeserializeFailed(
1070		result, element_qname);
1071	0	goto fail_deserialize;
1072		}
1073
1074	0	*ip = instance;
1075	0	goto exit;
1076		}
1077
1078	260	result = globus_soap_message_deserialize_element_begin_close(
1079		message_handle);
1080	260	if(result != GLOBUS_SUCCESS)
1081		{
1082	0	result = GlobusSoapMessageErrorDeserializeFailed(
1083		result, element_qname);
1084	0	goto exit;
1085		}
1086
1087	260	result = rptest_TestStepType_deserialize(
1088		element_qname,
1089		instance,
1090		message_handle,
1091		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1092
1093	260	result = globus_soap_message_deserialize_element_end(
1094		message_handle,
1095		element_qname);
1096	260	if(result != GLOBUS_SUCCESS)
1097		{
1098	0	result = GlobusSoapMessageErrorDeserializeFailed(
1099		result, element_qname);
1100	0	goto fail_deserialize;
1101		}
1102
1103	260	*ip = instance;
1104
1105	260	goto exit;
1106
1107		fail_deserialize:
1108
1109		_name_destroy:
1110		/* output_fail_destroy_attribute() */
1111
1112	0	if(instance->_name)
1113		{
1114	0	xsd_string_destroy(
1115		instance->_name);
1116	0	instance->_name = NULL;
1117		}
1118	0	rptest_TestStepType_choice_destroy_contents(
1119		&instance->choice_value);
1120
1121		choice_value_destroy:
1122
1123		exit:
1124
1125	260	GlobusSoapMessageDebugExit();
1126	260	return result;
1127		}
1128
1129
1130		globus_result_t
1131		rptest_TestStepType_array_init_contents(
1132		rptest_TestStepType_array * array)
1133	0	{
1134	0	return globus_xsd_generic_array_init_contents(
1135		(globus_xsd_generic_array_t *) array,
1136		&rptest_TestStepType_info);
1137		}
1138		/* rptest_TestStepType_array_init_contents() */
1139
1140		globus_result_t
1141		rptest_TestStepType_array_init(
1142		rptest_TestStepType_array ** arr)
1143	0	{
1144	0	return globus_xsd_generic_array_init(
1145		(globus_xsd_generic_array_t **) arr,
1146		&rptest_TestStepType_info);
1147		}
1148		/* rptest_TestStepType_array_init() */
1149
1150		void
1151		rptest_TestStepType_array_destroy_contents(
1152		rptest_TestStepType_array * array)
1153	40	{
1154	40	globus_xsd_generic_array_destroy_contents(
1155		(globus_xsd_generic_array_t *) array);
1156		}
1157		/* rptest_TestStepType_array_destroy_contents() */
1158
1159		void
1160		rptest_TestStepType_array_destroy(
1161		rptest_TestStepType_array * array)
1162	0	{
1163	0	globus_xsd_generic_array_destroy(
1164		(globus_xsd_generic_array_t *) array);
1165		}
1166		/* rptest_TestStepType_array_destroy() */
1167
1168		globus_result_t
1169		rptest_TestStepType_array_copy(
1170		rptest_TestStepType_array ** dest_arr,
1171		const rptest_TestStepType_array * src_arr)
1172	0	{
1173	0	return globus_xsd_generic_array_copy(
1174		(globus_xsd_generic_array_t **) dest_arr,
1175		(globus_xsd_generic_array_t *) src_arr);
1176		}
1177		/* rptest_TestStepType_array_copy() */
1178
1179		globus_result_t
1180		rptest_TestStepType_array_copy_contents(
1181		rptest_TestStepType_array * dest_arr,
1182		const rptest_TestStepType_array * src_arr)
1183	0	{
1184	0	return globus_xsd_generic_array_copy_contents(
1185		(globus_xsd_generic_array_t *) dest_arr,
1186		(globus_xsd_generic_array_t *) src_arr);
1187		}
1188		/* rptest_TestStepType_array_copy_contents() */
1189
1190		rptest_TestStepType *
1191		rptest_TestStepType_array_push(
1192		rptest_TestStepType_array * array)
1193	260	{
1194		/* Some contents initializers don't initialize subelments but to set their
1195		* values to be NULL
1196		*/
1197	260	if (array->type_info == NULL)
1198		{
1199	0	array->type_info = &rptest_TestStepType_info;
1200		}
1201
1202	260	return globus_xsd_generic_array_push(
1203		(globus_xsd_generic_array_t *) array);
1204		}
1205		/* rptest_TestStepType_array_push() */
1206
1207		void *
1208		rptest_TestStepType_array_push_wrapper(
1209		void * array)
1210	260	{
1211	260	return (void *) rptest_TestStepType_array_push((rptest_TestStepType_array *) array);
1212		}
1213
1214		globus_result_t
1215		rptest_TestStepType_array_serialize(
1216		const xsd_QName *                   element_qname,
1217		const rptest_TestStepType_array *        array,
1218		globus_soap_message_handle_t        message,
1219		globus_xsd_element_options_t        options)
1220	0	{
1221	0	return globus_xsd_generic_array_serialize(
1222		element_qname,
1223		(const globus_xsd_generic_array_t *) array,
1224		message,
1225		options);
1226		}
1227		/* rptest_TestStepType_array_serialize() */
1228
1229		globus_result_t
1230		rptest_TestStepType_array_deserialize(
1231		const xsd_QName *                   element_qname,
1232		rptest_TestStepType_array * array,
1233		globus_soap_message_handle_t        message,
1234		globus_xsd_element_options_t        options)
1235	40	{
1236		/* Some initializers set the array's contents to NULL */
1237	40	if (array->type_info == NULL)
1238		{
1239	40	array->type_info = &rptest_TestStepType_info;
1240		}
1241	40	return globus_xsd_generic_array_deserialize(
1242		element_qname,
1243		(globus_xsd_generic_array_t *) array,
1244		message,
1245		options);