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