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