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