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