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