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