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