1		/*
2		* Portions of this file Copyright 1999-2005 University of Chicago
3		* Portions of this file Copyright 1999-2005 The University of Southern California.
4		*
5		* This file or a portion of this file is licensed under the
6		* terms of the Globus Toolkit Public License, found at
7		* http://www.globus.org/toolkit/download/license.html.
8		* If you redistribute this file, with or without
9		* modifications, you must include this notice in the file.
10		*/
11
12
13		/*
14		* This file is automatically generated by the Globus WSDLtoC converter
15		*/
16
17		#include "xsd_QName.h"
18		#include "globus_soap_message.h"
19		#include "globus_xsd_type_info.h"
20		#include "ds_DSAKeyValueType.h"
21
22		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
23		xsd_QName ds_DSAKeyValueType_qname =
24		{
25		DS_DSAKEYVALUETYPE_NS,
26		DS_DSAKEYVALUETYPE_LOCAL
27		};
28		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
29
30		globus_result_t
31		ds_DSAKeyValueType_serialize_wrapper(
32		xsd_QName *                         element_qname,
33		void *                              instance,
34		globus_soap_message_handle_t        message_handle,
35		globus_xsd_element_options_t        options)
36	0	{
37	0	return ds_DSAKeyValueType_serialize(
38		element_qname,
39		(ds_DSAKeyValueType *) instance,
40		message_handle, options);
41		}
42
43		globus_result_t
44		ds_DSAKeyValueType_deserialize_pointer_wrapper(
45		xsd_QName *                         element_qname,
46		void **                             ip,
47		globus_soap_message_handle_t        message_handle,
48		globus_xsd_element_options_t        options)
49	0	{
50	0	return ds_DSAKeyValueType_deserialize_pointer(
51		element_qname,
52		(ds_DSAKeyValueType **) ip,
53		message_handle, options);
54		}
55
56		globus_result_t
57		ds_DSAKeyValueType_init_wrapper(void **object)
58	0	{
59	0	return ds_DSAKeyValueType_init(
60		(ds_DSAKeyValueType **) object);
61		}
62
63		void
64		ds_DSAKeyValueType_destroy_wrapper(
65		void *                          object)
66	0	{
67	0	ds_DSAKeyValueType_destroy(
68		(ds_DSAKeyValueType *) object);
69		}
70
71		globus_result_t
72		ds_DSAKeyValueType_copy_wrapper(
73		void **                         dest_obj,
74		void *                          src_obj)
75	0	{
76	0	return ds_DSAKeyValueType_copy(
77		(ds_DSAKeyValueType **) dest_obj,
78		(ds_DSAKeyValueType *) src_obj);
79		}
80
81		globus_result_t
82		ds_DSAKeyValueType_init_contents_wrapper(void *object)
83	0	{
84	0	return ds_DSAKeyValueType_init_contents(
85		(ds_DSAKeyValueType *) object);
86		}
87
88		void
89		ds_DSAKeyValueType_destroy_contents_wrapper(
90		void *                          object)
91	0	{
92	0	ds_DSAKeyValueType_destroy_contents(
93		(ds_DSAKeyValueType *) object);
94		}
95
96		globus_result_t
97		ds_DSAKeyValueType_copy_contents_wrapper(
98		void *                          dest_obj,
99		void *                          src_obj)
100	0	{
101	0	return ds_DSAKeyValueType_copy_contents(
102		(ds_DSAKeyValueType *) dest_obj,
103		(ds_DSAKeyValueType *) src_obj);
104		}
105
106		globus_result_t
107		ds_DSAKeyValueType_serialize_contents_wrapper(
108		xsd_QName *                         element_qname,
109		void *                              instance,
110		globus_soap_message_handle_t        message_handle,
111		globus_xsd_element_options_t        options)
112	0	{
113	0	return ds_DSAKeyValueType_serialize_contents(
114		element_qname,
115		(ds_DSAKeyValueType *) instance,
116		message_handle, options);
117		}
118
119		globus_result_t
120		ds_DSAKeyValueType_deserialize_contents_wrapper(
121		xsd_QName *                         element_qname,
122		void **                             instance,
123		globus_soap_message_handle_t        message_handle,
124		globus_xsd_element_options_t        options)
125	0	{
126	0	globus_result_t                     result;
127	0	GlobusFuncName(ds_DSAKeyValueType_deserialize_contents_wrapper);
128	0	GlobusSoapMessageDebugEnter();
129
130	0	if(!*instance)
131		{
132	0	result = ds_DSAKeyValueType_init(
133		(ds_DSAKeyValueType **)instance);
134	0	if(result != GLOBUS_SUCCESS)
135		{
136	0	goto error;
137		}
138		}
139
140	0	result = ds_DSAKeyValueType_deserialize_contents(
141		element_qname,
142		*(ds_DSAKeyValueType **)instance,
143		message_handle, options);
144		error:
145	0	GlobusSoapMessageDebugExit();
146	0	return result;
147		}
148
149		globus_result_t
150		ds_DSAKeyValueType_array_serialize_wrapper(
151		xsd_QName *                     element,
152		void *                          instance,
153		globus_soap_message_handle_t    message,
154		globus_xsd_element_options_t    options)
155	0	{
156	0	return ds_DSAKeyValueType_array_serialize(
157		element,
158		(ds_DSAKeyValueType_array *) instance,
159		message, options);
160		}
161
162		globus_result_t
163		ds_DSAKeyValueType_array_deserialize_wrapper(
164		xsd_QName *                         element_qname,
165		void **                             inst,
166		globus_soap_message_handle_t        message,
167		globus_xsd_element_options_t        options)
168	0	{
169	0	if(!*inst)
170		{
171	0	globus_result_t                 result;
172
173	0	result = ds_DSAKeyValueType_array_init(
174		(ds_DSAKeyValueType_array **)inst);
175	0	if(result != GLOBUS_SUCCESS)
176		{
177	0	return result;
178		}
179		}
180
181	0	return ds_DSAKeyValueType_array_deserialize(
182		element_qname,
183		*(ds_DSAKeyValueType_array **) inst,
184		message, options);
185		}
186
187		globus_result_t
188		ds_DSAKeyValueType_array_init_wrapper(
189		void **                             arr)
190	0	{
191	0	return ds_DSAKeyValueType_array_init(
192		(ds_DSAKeyValueType_array **) arr);
193		}
194
195		void
196		ds_DSAKeyValueType_array_destroy_wrapper(
197		void *                              arr)
198	0	{
199	0	ds_DSAKeyValueType_array_destroy(
200		(ds_DSAKeyValueType_array *) arr);
201		}
202
203		globus_result_t
204		ds_DSAKeyValueType_array_copy_wrapper(
205		void **                             dest_arr,
206		void *                              src_arr)
207	0	{
208	0	return ds_DSAKeyValueType_array_copy(
209		(ds_DSAKeyValueType_array **) dest_arr,
210		(ds_DSAKeyValueType_array *) src_arr);
211		}
212
213		globus_result_t
214		ds_DSAKeyValueType_array_init_contents_wrapper(
215		void *                              arr)
216	0	{
217	0	return ds_DSAKeyValueType_array_init_contents(
218		(ds_DSAKeyValueType_array *) arr);
219		}
220
221		void
222		ds_DSAKeyValueType_array_destroy_contents_wrapper(
223		void *                              arr)
224	0	{
225	0	ds_DSAKeyValueType_array_destroy_contents(
226		(ds_DSAKeyValueType_array *) arr);
227		}
228
229		globus_result_t
230		ds_DSAKeyValueType_array_copy_contents_wrapper(
231		void *                              dest_arr,
232		void *                              src_arr)
233	0	{
234	0	return ds_DSAKeyValueType_array_copy_contents(
235		(ds_DSAKeyValueType_array *) dest_arr,
236		(ds_DSAKeyValueType_array *) src_arr);
237		}
238
239		struct globus_xsd_type_info_s ds_DSAKeyValueType_contents_info =
240		{
241		&ds_DSAKeyValueType_qname,
242		ds_DSAKeyValueType_serialize_contents_wrapper,
243		ds_DSAKeyValueType_deserialize_contents_wrapper,
244		ds_DSAKeyValueType_init_wrapper,
245		ds_DSAKeyValueType_destroy_wrapper,
246		ds_DSAKeyValueType_copy_wrapper,
247		ds_DSAKeyValueType_init_contents_wrapper,
248		ds_DSAKeyValueType_destroy_contents_wrapper,
249		ds_DSAKeyValueType_copy_contents_wrapper,
250		sizeof(ds_DSAKeyValueType),
251		NULL,
252		NULL,
253		NULL
254		};
255
256		struct globus_xsd_type_info_s ds_DSAKeyValueType_array_info =
257		{
258		&ds_DSAKeyValueType_qname,
259		ds_DSAKeyValueType_array_serialize_wrapper,
260		ds_DSAKeyValueType_array_deserialize_wrapper,
261		ds_DSAKeyValueType_array_init_wrapper,
262		ds_DSAKeyValueType_array_destroy_wrapper,
263		ds_DSAKeyValueType_array_copy_wrapper,
264		ds_DSAKeyValueType_array_init_contents_wrapper,
265		ds_DSAKeyValueType_array_destroy_contents_wrapper,
266		ds_DSAKeyValueType_array_copy_contents_wrapper,
267		sizeof(ds_DSAKeyValueType),
268		ds_DSAKeyValueType_array_push_wrapper,
269		NULL,
270		NULL
271		};
272
273		struct globus_xsd_type_info_s ds_DSAKeyValueType_info =
274		{
275		&ds_DSAKeyValueType_qname,
276		ds_DSAKeyValueType_serialize_wrapper,
277		ds_DSAKeyValueType_deserialize_pointer_wrapper,
278		ds_DSAKeyValueType_init_wrapper,
279		ds_DSAKeyValueType_destroy_wrapper,
280		ds_DSAKeyValueType_copy_wrapper,
281		ds_DSAKeyValueType_init_contents_wrapper,
282		ds_DSAKeyValueType_destroy_contents_wrapper,
283		ds_DSAKeyValueType_copy_contents_wrapper,
284		sizeof(ds_DSAKeyValueType),
285		NULL,
286		&ds_DSAKeyValueType_contents_info,
287		&ds_DSAKeyValueType_array_info
288		};
289
290		globus_result_t
291		ds_DSAKeyValueType_init_contents(
292		ds_DSAKeyValueType * instance)
293	0	{
294	0	globus_result_t                     result = GLOBUS_SUCCESS;
295	0	GlobusFuncName(ds_DSAKeyValueType_init_contents);
296	0	GlobusSoapMessageDebugEnter();
297
298	0	memset(instance, 0, sizeof(ds_DSAKeyValueType));
299
300	0	GlobusSoapMessageDebugExit();
301	0	return result;
302		}
303
304		globus_result_t
305		ds_DSAKeyValueType_init(
306		ds_DSAKeyValueType ** object)
307	0	{
308	0	ds_DSAKeyValueType * instance;
309	0	globus_result_t                     result = GLOBUS_SUCCESS;
310	0	GlobusFuncName(ds_DSAKeyValueType_init);
311	0	GlobusSoapMessageDebugEnter();
312
313	0	instance = globus_malloc(sizeof(ds_DSAKeyValueType));
314	0	if(!instance)
315		{
316	0	result = GlobusSoapMessageErrorOutOfMemory;
317	0	goto exit;
318		}
319
320	0	memset(instance, 0, sizeof(ds_DSAKeyValueType));
321
322	0	*object = instance;
323
324		exit:
325	0	GlobusSoapMessageDebugExit();
326	0	return result;
327		}
328
329		void
330		ds_DSAKeyValueType_destroy(
331		ds_DSAKeyValueType * instance)
332	0	{
333	0	GlobusFuncName(ds_DSAKeyValueType_destroy);
334	0	GlobusSoapMessageDebugEnter();
335
336	0	if(!instance)
337		{
338	0	goto exit;
339		}
340
341	0	ds_DSAKeyValueType_destroy_contents(instance);
342	0	globus_free(instance);
343
344		exit:
345
346	0	GlobusSoapMessageDebugExit();
347		}
348
349		void
350		ds_DSAKeyValueType_destroy_contents(
351		ds_DSAKeyValueType * instance)
352	0	{
353	0	GlobusFuncName(ds_DSAKeyValueType_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	if(instance)
357		{
358
359
360	0	ds_CryptoBinary_destroy_contents(
361		&instance->P);
362
363	0	ds_CryptoBinary_destroy_contents(
364		&instance->Q);
365
366	0	ds_CryptoBinary_destroy(instance->G);
367	0	instance->G = NULL;
368
369	0	ds_CryptoBinary_destroy_contents(
370		&instance->Y);
371
372	0	ds_CryptoBinary_destroy(instance->J);
373	0	instance->J = NULL;
374
375	0	ds_CryptoBinary_destroy_contents(
376		&instance->Seed);
377
378	0	ds_CryptoBinary_destroy_contents(
379		&instance->PgenCounter);
380
381		}
382
383	0	GlobusSoapMessageDebugExit();
384		}
385
386		globus_result_t
387		ds_DSAKeyValueType_copy(
388		ds_DSAKeyValueType ** dest_obj,
389		const ds_DSAKeyValueType * src_obj)
390	0	{
391	0	globus_result_t                     result = GLOBUS_SUCCESS;
392	0	ds_DSAKeyValueType * instance;
393	0	GlobusFuncName(ds_DSAKeyValueType_copy);
394
395	0	GlobusSoapMessageDebugEnter();
396
397	0	instance = malloc(sizeof(ds_DSAKeyValueType));
398	0	if (instance == NULL)
399		{
400	0	GlobusSoapMessageDebugExit();
401	0	return GlobusSoapMessageErrorOutOfMemory;
402		}
403
404	0	result = ds_DSAKeyValueType_copy_contents(instance, src_obj);
405	0	if(result != GLOBUS_SUCCESS)
406		{
407	0	globus_free(instance);
408	0	GlobusSoapMessageDebugExit();
409	0	return GlobusSoapMessageErrorOutOfMemory;
410		}
411
412	0	*dest_obj = instance;
413	0	GlobusSoapMessageDebugExit();
414	0	return result;
415		}
416
417		globus_result_t
418		ds_DSAKeyValueType_copy_contents(
419		ds_DSAKeyValueType * instance,
420		const ds_DSAKeyValueType * src_obj)
421	0	{
422	0	globus_result_t                     result = GLOBUS_SUCCESS;
423	0	GlobusFuncName(ds_DSAKeyValueType_copy_contents);
424
425	0	GlobusSoapMessageDebugEnter();
426
427
428	0	result = ds_CryptoBinary_copy_contents(
429		&instance->P,
430		&src_obj->P);
431	0	if(result != GLOBUS_SUCCESS)
432		{
433	0	result = GlobusSoapMessageErrorCopyFailed(
434		result, NULL, &ds_CryptoBinary_qname);
435	0	goto P_destroy;
436		}
437
438	0	result = ds_CryptoBinary_copy_contents(
439		&instance->Q,
440		&src_obj->Q);
441	0	if(result != GLOBUS_SUCCESS)
442		{
443	0	result = GlobusSoapMessageErrorCopyFailed(
444		result, NULL, &ds_CryptoBinary_qname);
445	0	goto Q_destroy;
446		}
447
448	0	if(src_obj->G)
449		{
450	0	result = ds_CryptoBinary_copy(
451		&instance->G,
452		src_obj->G);
453	0	if(result != GLOBUS_SUCCESS)
454		{
455	0	result = GlobusSoapMessageErrorCopyFailed(
456		result, NULL, &ds_CryptoBinary_qname);
457	0	goto G_destroy_pointer;
458		}
459		}
460		else
461		{
462	0	instance->G = NULL;
463		}
464
465	0	result = ds_CryptoBinary_copy_contents(
466		&instance->Y,
467		&src_obj->Y);
468	0	if(result != GLOBUS_SUCCESS)
469		{
470	0	result = GlobusSoapMessageErrorCopyFailed(
471		result, NULL, &ds_CryptoBinary_qname);
472	0	goto Y_destroy;
473		}
474
475	0	if(src_obj->J)
476		{
477	0	result = ds_CryptoBinary_copy(
478		&instance->J,
479		src_obj->J);
480	0	if(result != GLOBUS_SUCCESS)
481		{
482	0	result = GlobusSoapMessageErrorCopyFailed(
483		result, NULL, &ds_CryptoBinary_qname);
484	0	goto J_destroy_pointer;
485		}
486		}
487		else
488		{
489	0	instance->J = NULL;
490		}
491
492	0	result = ds_CryptoBinary_copy_contents(
493		&instance->Seed,
494		&src_obj->Seed);
495	0	if(result != GLOBUS_SUCCESS)
496		{
497	0	result = GlobusSoapMessageErrorCopyFailed(
498		result, NULL, &ds_CryptoBinary_qname);
499	0	goto Seed_destroy;
500		}
501
502	0	result = ds_CryptoBinary_copy_contents(
503		&instance->PgenCounter,
504		&src_obj->PgenCounter);
505	0	if(result != GLOBUS_SUCCESS)
506		{
507	0	result = GlobusSoapMessageErrorCopyFailed(
508		result, NULL, &ds_CryptoBinary_qname);
509		goto PgenCounter_destroy;
510		}
511
512	0	goto exit;
513
514		fail_deserialize:
515	0	ds_CryptoBinary_destroy_contents(
516		&instance->PgenCounter);
517
518		PgenCounter_destroy:
519	0	ds_CryptoBinary_destroy_contents(
520		&instance->Seed);
521
522		Seed_destroy:
523	0	ds_CryptoBinary_destroy(
524		instance->J);
525	0	instance->J = NULL;
526
527		J_destroy_pointer:
528	0	ds_CryptoBinary_destroy_contents(
529		&instance->Y);
530
531		Y_destroy:
532	0	ds_CryptoBinary_destroy(
533		instance->G);
534	0	instance->G = NULL;
535
536		G_destroy_pointer:
537	0	ds_CryptoBinary_destroy_contents(
538		&instance->Q);
539
540		Q_destroy:
541	0	ds_CryptoBinary_destroy_contents(
542		&instance->P);
543
544		P_destroy:
545
546
547		exit:
548
549	0	GlobusSoapMessageDebugExit();
550	0	return result;
551		}
552
553
554
555		globus_result_t
556		ds_DSAKeyValueType_serialize_contents(
557		xsd_QName *                         element_qname, /* ignored */
558		ds_DSAKeyValueType * inst,
559		globus_soap_message_handle_t        message_handle,
560		globus_xsd_element_options_t        options)
561	0	{
562	0	globus_result_t                     result = GLOBUS_SUCCESS;
563	0	GlobusFuncName(ds_DSAKeyValueType_serialize_contents);
564	0	GlobusSoapMessageDebugEnter();
565
566	0	result = ds_DSAKeyValueType_serialize(
567		NULL,
568		inst,
569		message_handle,
570		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
571	0	if(result != GLOBUS_SUCCESS)
572		{
573	0	result = GlobusSoapMessageErrorSerializeFailed(
574		result, NULL, element_qname);
575		goto exit;
576		}
577
578		exit:
579
580	0	GlobusSoapMessageDebugExit();
581	0	return result;
582		}
583
584
585
586		globus_result_t
587		ds_DSAKeyValueType_serialize(
588		xsd_QName *                         element_qname,
589		ds_DSAKeyValueType * instance,
590		globus_soap_message_handle_t        message_handle,
591		globus_xsd_element_options_t        options)
592	0	{
593	0	globus_result_t                     result = GLOBUS_SUCCESS;
594	0	xsd_QName                           subelement;
595	0	globus_list_t *                     any_attr_keys = NULL;
596	0	globus_list_t *                     any_attr_keys_iterator = NULL;
597	0	xsd_QName *                         type_attr = NULL;
598	0	char *                              prefix = NULL;
599	0	int                                 prefix_created;
600	0	int                                 define_prefix = 0;
601	0	int                                 save_options = options;
602
603	0	GlobusFuncName(ds_DSAKeyValueType_serialize);
604	0	GlobusSoapMessageDebugEnter();
605
606
607	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
608		{
609		/* serialize ds_DSAKeyValueType element */
610
611	0	result = globus_soap_message_invoke_ns_callouts(
612		message_handle,
613		element_qname,
614		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_SET,
615		&options);
616	0	if(result != GLOBUS_SUCCESS)
617		{
618	0	result = GlobusSoapMessageErrorSerializeFailed(
619		result, NULL, element_qname);
620	0	goto exit;
621		}
622
623	0	result = globus_soap_message_element_ns_set(
624		message_handle,
625		element_qname->Namespace,
626		&options);
627	0	if(result != GLOBUS_SUCCESS)
628		{
629	0	result = GlobusSoapMessageErrorSerializeFailed(
630		result, NULL, element_qname);
631	0	goto exit;
632		}
633
634	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
635		!globus_soap_message_serialize_is_c14n_subset(message_handle))
636		{
637	0	result = globus_soap_message_attribute_ns_set(
638		message_handle,
639		"http://www.w3.org/2001/XMLSchema-instance",
640		&options);
641	0	if(result != GLOBUS_SUCCESS)
642		{
643	0	result = GlobusSoapMessageErrorSerializeFailed(
644		result, NULL, element_qname);
645	0	goto exit;
646		}
647
648	0	result = globus_soap_message_attribute_ns_set(
649		message_handle,
650		ds_DSAKeyValueType_qname.Namespace,
651		&options);
652	0	if(result != GLOBUS_SUCCESS)
653		{
654	0	result = GlobusSoapMessageErrorSerializeFailed(
655		result, NULL, element_qname);
656	0	goto exit;
657		}
658		}
659
660	0	result = globus_soap_message_invoke_callouts(
661		message_handle,
662		element_qname,
663		GLOBUS_SOAP_MESSAGE_CALLOUT_BEGIN);
664	0	if(result != GLOBUS_SUCCESS)
665		{
666	0	result = GlobusSoapMessageErrorSerializeFailed(
667		result, NULL, element_qname);
668	0	goto exit;
669		}
670
671	0	result = globus_soap_message_serialize_element(
672		message_handle,
673		element_qname,
674		options,
675		&ds_DSAKeyValueType_qname);
676	0	if(result != GLOBUS_SUCCESS)
677		{
678	0	result = GlobusSoapMessageErrorSerializeFailed(
679		result, NULL, element_qname);
680	0	goto exit;
681		}
682
683	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
684		!globus_soap_message_serialize_is_c14n_subset(message_handle))
685		{
686	0	xsd_QName_init(&type_attr);
687
688	0	type_attr->local = globus_libc_strdup("type");
689	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
690		}
691
692		/* serialize namespaces */
693
694	0	result = globus_soap_message_invoke_ns_callouts(
695		message_handle,
696		element_qname,
697		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_ADD,
698		&options);
699	0	if(result != GLOBUS_SUCCESS)
700		{
701	0	result = GlobusSoapMessageErrorSerializeFailed(
702		result, NULL, element_qname);
703	0	goto exit;
704		}
705
706	0	result = globus_soap_message_element_ns_add(
707		message_handle,
708		element_qname->Namespace,
709		&options);
710	0	if(result != GLOBUS_SUCCESS)
711		{
712	0	result = GlobusSoapMessageErrorSerializeFailed(
713		result, NULL, element_qname);
714	0	goto exit;
715		}
716
717	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
718		!globus_soap_message_serialize_is_c14n_subset(message_handle))
719		{
720	0	result = globus_soap_message_attribute_ns_add(
721		message_handle,
722		"http://www.w3.org/2001/XMLSchema-instance",
723		&options);
724	0	if(result != GLOBUS_SUCCESS)
725		{
726	0	result = GlobusSoapMessageErrorSerializeFailed(
727		result, NULL, element_qname);
728	0	goto exit;
729		}
730
731	0	result = globus_soap_message_attribute_ns_add(
732		message_handle,
733		ds_DSAKeyValueType_qname.Namespace,
734		&options);
735	0	if(result != GLOBUS_SUCCESS)
736		{
737	0	result = GlobusSoapMessageErrorSerializeFailed(
738		result, NULL, element_qname);
739	0	goto exit;
740		}
741		}
742
743		/* serialize attributes */
744
745	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
746		!globus_soap_message_serialize_is_c14n_subset(message_handle))
747		{
748	0	result = globus_soap_message_serialize_QName_attribute(
749		message_handle,
750		type_attr,
751		&ds_DSAKeyValueType_qname);
752	0	if(result != GLOBUS_SUCCESS)
753		{
754	0	result = GlobusSoapMessageErrorSerializeFailed(
755		result, NULL, element_qname);
756	0	goto exit;
757		}
758		}
759
760
761	0	result = globus_soap_message_invoke_callouts(
762		message_handle,
763		element_qname,
764		GLOBUS_SOAP_MESSAGE_CALLOUT_ATTR);
765	0	if(result != GLOBUS_SUCCESS)
766		{
767	0	result = GlobusSoapMessageErrorSerializeFailed(
768		result, NULL, element_qname);
769	0	goto exit;
770		}
771		}
772
773	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
774		{
775	0	result = globus_soap_message_serialize_element_begin_close(
776		message_handle);
777	0	if(result != GLOBUS_SUCCESS)
778		{
779	0	result = GlobusSoapMessageErrorSerializeFailed(
780		result, NULL, element_qname);
781	0	goto exit;
782		}
783		}
784	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
785
786		/* serialize contents of type */
787
788	0	subelement.local = "P";
789	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
790
791	0	result = ds_CryptoBinary_serialize(
792		&subelement,
793		&instance->P,
794		message_handle,
795		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
796	0	if(result != GLOBUS_SUCCESS)
797		{
798	0	result = GlobusSoapMessageErrorSerializeFailed(
799		result, NULL, &ds_CryptoBinary_qname);
800	0	goto exit;
801		}
802
803	0	subelement.local = "Q";
804	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
805
806	0	result = ds_CryptoBinary_serialize(
807		&subelement,
808		&instance->Q,
809		message_handle,
810		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
811	0	if(result != GLOBUS_SUCCESS)
812		{
813	0	result = GlobusSoapMessageErrorSerializeFailed(
814		result, NULL, &ds_CryptoBinary_qname);
815	0	goto exit;
816		}
817
818	0	subelement.local = "G";
819	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
820
821	0	if(instance->G)
822		{
823	0	result = ds_CryptoBinary_serialize(
824		&subelement,
825		instance->G,
826		message_handle,
827		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
828	0	if(result != GLOBUS_SUCCESS)
829		{
830	0	result = GlobusSoapMessageErrorSerializeFailed(
831		result, NULL, &ds_CryptoBinary_qname);
832	0	goto exit;
833		}
834		}
835
836	0	subelement.local = "Y";
837	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
838
839	0	result = ds_CryptoBinary_serialize(
840		&subelement,
841		&instance->Y,
842		message_handle,
843		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
844	0	if(result != GLOBUS_SUCCESS)
845		{
846	0	result = GlobusSoapMessageErrorSerializeFailed(
847		result, NULL, &ds_CryptoBinary_qname);
848	0	goto exit;
849		}
850
851	0	subelement.local = "J";
852	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
853
854	0	if(instance->J)
855		{
856	0	result = ds_CryptoBinary_serialize(
857		&subelement,
858		instance->J,
859		message_handle,
860		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
861	0	if(result != GLOBUS_SUCCESS)
862		{
863	0	result = GlobusSoapMessageErrorSerializeFailed(
864		result, NULL, &ds_CryptoBinary_qname);
865	0	goto exit;
866		}
867		}
868
869	0	subelement.local = "Seed";
870	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
871
872	0	result = ds_CryptoBinary_serialize(
873		&subelement,
874		&instance->Seed,
875		message_handle,
876		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
877	0	if(result != GLOBUS_SUCCESS)
878		{
879	0	result = GlobusSoapMessageErrorSerializeFailed(
880		result, NULL, &ds_CryptoBinary_qname);
881	0	goto exit;
882		}
883
884	0	subelement.local = "PgenCounter";
885	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
886
887	0	result = ds_CryptoBinary_serialize(
888		&subelement,
889		&instance->PgenCounter,
890		message_handle,
891		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
892	0	if(result != GLOBUS_SUCCESS)
893		{
894	0	result = GlobusSoapMessageErrorSerializeFailed(
895		result, NULL, &ds_CryptoBinary_qname);
896	0	goto exit;
897		}
898
899	0	options = save_options;
900
901	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
902		{
903		/* add end element */
904	0	result = globus_soap_message_serialize_element_end(
905		message_handle,
906		element_qname,
907		options,
908		&ds_DSAKeyValueType_qname);
909	0	if(result != GLOBUS_SUCCESS)
910		{
911	0	result = GlobusSoapMessageErrorSerializeFailed(
912		result, NULL, element_qname);
913	0	goto exit;
914		}
915
916	0	globus_soap_message_element_ns_remove(
917		message_handle,
918		element_qname->Namespace,
919		&options);
920
921		/* remove namespace/prefix mappings for these types */
922
923	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
924		!globus_soap_message_serialize_is_c14n_subset(message_handle))
925		{
926	0	globus_soap_message_attribute_ns_remove(
927		message_handle,
928		"http://www.w3.org/2001/XMLSchema-instance",
929		&options);
930
931	0	globus_soap_message_attribute_ns_remove(
932		message_handle,
933		ds_DSAKeyValueType_qname.Namespace,
934		&options);
935		}
936
937	0	result = globus_soap_message_invoke_ns_callouts(
938		message_handle,
939		element_qname,
940		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_REMOVE,
941		&options);
942	0	if(result != GLOBUS_SUCCESS)
943		{
944	0	result  = GlobusSoapMessageErrorSerializeFailed(
945		result, NULL, element_qname);
946	0	goto exit;
947		}
948
949	0	result = globus_soap_message_invoke_callouts(
950		message_handle,
951		element_qname,
952		GLOBUS_SOAP_MESSAGE_CALLOUT_END);
953	0	if(result != GLOBUS_SUCCESS)
954		{
955	0	result = GlobusSoapMessageErrorSerializeFailed(
956		result, NULL, element_qname);
957		goto exit;
958		}
959		}
960
961		exit:
962	0	if (type_attr)
963		{
964	0	xsd_QName_destroy(type_attr);
965		}
966
967	0	if(any_attr_keys)
968		{
969	0	globus_list_free(any_attr_keys);
970		}
971
972	0	GlobusSoapMessageDebugExit();
973	0	return result;
974		}
975
976
977
978		globus_result_t
979		ds_DSAKeyValueType_deserialize_contents(
980		xsd_QName *                         element_qname, /* ignored */
981		ds_DSAKeyValueType * inst,
982		globus_soap_message_handle_t        message_handle,
983		globus_xsd_element_options_t        options)
984	0	{
985	0	globus_result_t                     result = GLOBUS_SUCCESS;
986	0	GlobusFuncName(ds_DSAKeyValueType_deserialize_contents);
987	0	GlobusSoapMessageDebugEnter();
988
989	0	result = ds_DSAKeyValueType_deserialize(
990		NULL,
991		inst,
992		message_handle,
993		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
994	0	if(result != GLOBUS_SUCCESS)
995		{
996	0	result = GlobusSoapMessageErrorDeserializeFailed(
997		result, element_qname);
998		goto exit;
999		}
1000
1001		exit:
1002
1003	0	GlobusSoapMessageDebugExit();
1004	0	return result;
1005		}
1006
1007
1008
1009		globus_result_t
1010		ds_DSAKeyValueType_deserialize(
1011		xsd_QName *                         element_qname,
1012		ds_DSAKeyValueType * instance,
1013		globus_soap_message_handle_t        message_handle,
1014		globus_xsd_element_options_t        options)
1015	0	{
1016	0	globus_result_t                     result = GLOBUS_SUCCESS;
1017	0	xsd_QName                           subelement;
1018	0	GlobusFuncName(ds_DSAKeyValueType_deserialize);
1019	0	GlobusSoapMessageDebugEnter();
1020
1021
1022	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1023		{
1024	0	result = globus_soap_message_deserialize_element(
1025		message_handle, element_qname);
1026	0	if(result != GLOBUS_SUCCESS)
1027		{
1028	0	result = GlobusSoapMessageErrorDeserializeFailed(
1029		result, element_qname);
1030	0	goto exit;
1031		}
1032
1033
1034	0	result = globus_soap_message_deserialize_element_begin_close(
1035		message_handle);
1036	0	if(result != GLOBUS_SUCCESS)
1037		{
1038	0	result = GlobusSoapMessageErrorDeserializeFailed(
1039		result, element_qname);
1040	0	goto fail_deserialize;
1041		}
1042		}
1043
1044	0	subelement.local = "P";
1045	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1046
1047	0	result = ds_CryptoBinary_deserialize(
1048		&subelement,
1049		&instance->P,
1050		message_handle,
1051		0);
1052	0	if(result != GLOBUS_SUCCESS)
1053		{
1054	0	result = GlobusSoapMessageErrorDeserializeFailed(
1055		result,
1056		&ds_CryptoBinary_qname);
1057	0	goto P_destroy;
1058		}
1059
1060	0	subelement.local = "Q";
1061	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1062
1063	0	result = ds_CryptoBinary_deserialize(
1064		&subelement,
1065		&instance->Q,
1066		message_handle,
1067		0);
1068	0	if(result != GLOBUS_SUCCESS)
1069		{
1070	0	result = GlobusSoapMessageErrorDeserializeFailed(
1071		result,
1072		&ds_CryptoBinary_qname);
1073	0	goto Q_destroy;
1074		}
1075
1076	0	subelement.local = "G";
1077	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1078
1079	0	result = ds_CryptoBinary_deserialize_pointer(
1080		&subelement,
1081		&instance->G,
1082		message_handle,
1083		0);
1084	0	if(result != GLOBUS_SUCCESS)
1085		{
1086	0	result = GlobusSoapMessageErrorDeserializeFailed(
1087		result,
1088		(&subelement));
1089	0	goto G_destroy_pointer;
1090		}
1091
1092	0	subelement.local = "Y";
1093	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1094
1095	0	result = ds_CryptoBinary_deserialize(
1096		&subelement,
1097		&instance->Y,
1098		message_handle,
1099		0);
1100	0	if(result != GLOBUS_SUCCESS)
1101		{
1102	0	result = GlobusSoapMessageErrorDeserializeFailed(
1103		result,
1104		&ds_CryptoBinary_qname);
1105	0	goto Y_destroy;
1106		}
1107
1108	0	subelement.local = "J";
1109	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1110
1111	0	result = ds_CryptoBinary_deserialize_pointer(
1112		&subelement,
1113		&instance->J,
1114		message_handle,
1115		0);
1116	0	if(result != GLOBUS_SUCCESS)
1117		{
1118	0	result = GlobusSoapMessageErrorDeserializeFailed(
1119		result,
1120		(&subelement));
1121	0	goto J_destroy_pointer;
1122		}
1123
1124	0	subelement.local = "Seed";
1125	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1126
1127	0	result = ds_CryptoBinary_deserialize(
1128		&subelement,
1129		&instance->Seed,
1130		message_handle,
1131		0);
1132	0	if(result != GLOBUS_SUCCESS)
1133		{
1134	0	result = GlobusSoapMessageErrorDeserializeFailed(
1135		result,
1136		&ds_CryptoBinary_qname);
1137	0	goto Seed_destroy;
1138		}
1139
1140	0	subelement.local = "PgenCounter";
1141	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1142
1143	0	result = ds_CryptoBinary_deserialize(
1144		&subelement,
1145		&instance->PgenCounter,
1146		message_handle,
1147		0);
1148	0	if(result != GLOBUS_SUCCESS)
1149		{
1150	0	result = GlobusSoapMessageErrorDeserializeFailed(
1151		result,
1152		&ds_CryptoBinary_qname);
1153	0	goto PgenCounter_destroy;
1154		}
1155
1156	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1157		{
1158	0	result = globus_soap_message_deserialize_element_end(
1159		message_handle,
1160		element_qname);
1161	0	if(result != GLOBUS_SUCCESS)
1162		{
1163	0	result = GlobusSoapMessageErrorDeserializeFailed(
1164		result, element_qname);
1165		goto fail_deserialize;
1166		}
1167		}
1168
1169	0	goto exit;
1170
1171		fail_deserialize:
1172	0	ds_CryptoBinary_destroy_contents(
1173		&instance->PgenCounter);
1174
1175		PgenCounter_destroy:
1176	0	ds_CryptoBinary_destroy_contents(
1177		&instance->Seed);
1178
1179		Seed_destroy:
1180	0	ds_CryptoBinary_destroy(
1181		instance->J);
1182	0	instance->J = NULL;
1183
1184		J_destroy_pointer:
1185	0	ds_CryptoBinary_destroy_contents(
1186		&instance->Y);
1187
1188		Y_destroy:
1189	0	ds_CryptoBinary_destroy(
1190		instance->G);
1191	0	instance->G = NULL;
1192
1193		G_destroy_pointer:
1194	0	ds_CryptoBinary_destroy_contents(
1195		&instance->Q);
1196
1197		Q_destroy:
1198	0	ds_CryptoBinary_destroy_contents(
1199		&instance->P);
1200
1201		P_destroy:
1202
1203
1204		exit:
1205
1206	0	GlobusSoapMessageDebugExit();
1207	0	return result;
1208		}
1209
1210
1211
1212		globus_result_t
1213		ds_DSAKeyValueType_deserialize_pointer(
1214		xsd_QName *                         element_qname,
1215		ds_DSAKeyValueType ** ip,
1216		globus_soap_message_handle_t        message_handle,
1217		globus_xsd_element_options_t        options)
1218	0	{
1219	0	ds_DSAKeyValueType * instance = NULL;
1220	0	globus_result_t                     result = GLOBUS_SUCCESS;
1221	0	xsd_QName                           subelement;
1222	0	int                                 found_attrs = 0;
1223	0	int                                 empty_element = 0;
1224	0	GlobusFuncName(ds_DSAKeyValueType_deserialize_pointer);
1225	0	GlobusSoapMessageDebugEnter();
1226
1227	0	*ip = NULL;
1228
1229	0	result = globus_soap_message_deserialize_element(
1230		message_handle, element_qname);
1231	0	if(result != GLOBUS_SUCCESS &&
1232		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1233		GlobusSoapMessageStatusFailedElementCheck(result) ||
1234		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1235		{
1236	0	*ip = NULL;
1237	0	result = GLOBUS_SUCCESS;
1238	0	goto exit;
1239		}
1240
1241	0	if(result != GLOBUS_SUCCESS)
1242		{
1243	0	result = GlobusSoapMessageErrorDeserializeFailed(
1244		result, element_qname);
1245	0	goto exit;
1246		}
1247
1248	0	if(globus_soap_message_deserialize_element_is_empty(
1249		message_handle))
1250		{
1251	0	empty_element = 1;
1252		}
1253
1254
1255
1256	0	result = ds_DSAKeyValueType_init(&instance);
1257	0	if(result != GLOBUS_SUCCESS)
1258		{
1259	0	result = GlobusSoapMessageErrorDeserializeFailed(
1260		result, element_qname);
1261	0	goto exit;
1262		}
1263
1264
1265	0	if(found_attrs == 0 &&
1266		globus_soap_message_deserialize_element_is_nil(message_handle))
1267		{
1268	0	ds_DSAKeyValueType_destroy(instance);
1269
1270	0	result = globus_soap_message_deserialize_element_end(
1271		message_handle,
1272		element_qname);
1273	0	if(result != GLOBUS_SUCCESS)
1274		{
1275	0	result = GlobusSoapMessageErrorDeserializeFailed(
1276		result, element_qname);
1277	0	goto exit;
1278		}
1279
1280	0	*ip = NULL;
1281	0	globus_object_free(globus_error_get(result));
1282	0	result = GLOBUS_SUCCESS;
1283	0	goto exit;
1284		}
1285
1286
1287	0	if(empty_element)
1288		{
1289	0	result = globus_soap_message_deserialize_element_end(
1290		message_handle,
1291		element_qname);
1292	0	if(result != GLOBUS_SUCCESS)
1293		{
1294	0	result = GlobusSoapMessageErrorDeserializeFailed(
1295		result, element_qname);
1296	0	goto fail_deserialize;
1297		}
1298
1299	0	*ip = instance;
1300	0	goto exit;
1301		}
1302
1303	0	result = globus_soap_message_deserialize_element_begin_close(
1304		message_handle);
1305	0	if(result != GLOBUS_SUCCESS)
1306		{
1307	0	result = GlobusSoapMessageErrorDeserializeFailed(
1308		result, element_qname);
1309	0	goto exit;
1310		}
1311
1312
1313	0	subelement.local = "P";
1314	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1315
1316	0	result = ds_CryptoBinary_deserialize(
1317		&subelement,
1318		&instance->P,
1319		message_handle,
1320		0);
1321	0	if(result != GLOBUS_SUCCESS)
1322		{
1323	0	result = GlobusSoapMessageErrorDeserializeFailed(
1324		result,
1325		&ds_CryptoBinary_qname);
1326	0	goto P_destroy;
1327		}
1328
1329	0	subelement.local = "Q";
1330	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1331
1332	0	result = ds_CryptoBinary_deserialize(
1333		&subelement,
1334		&instance->Q,
1335		message_handle,
1336		0);
1337	0	if(result != GLOBUS_SUCCESS)
1338		{
1339	0	result = GlobusSoapMessageErrorDeserializeFailed(
1340		result,
1341		&ds_CryptoBinary_qname);
1342	0	goto Q_destroy;
1343		}
1344
1345	0	subelement.local = "G";
1346	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1347
1348	0	result = ds_CryptoBinary_deserialize_pointer(
1349		&subelement,
1350		&instance->G,
1351		message_handle,
1352		0);
1353	0	if(result != GLOBUS_SUCCESS)
1354		{
1355	0	result = GlobusSoapMessageErrorDeserializeFailed(
1356		result,
1357		(&subelement));
1358	0	goto G_destroy_pointer;
1359		}
1360
1361	0	subelement.local = "Y";
1362	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1363
1364	0	result = ds_CryptoBinary_deserialize(
1365		&subelement,
1366		&instance->Y,
1367		message_handle,
1368		0);
1369	0	if(result != GLOBUS_SUCCESS)
1370		{
1371	0	result = GlobusSoapMessageErrorDeserializeFailed(
1372		result,
1373		&ds_CryptoBinary_qname);
1374	0	goto Y_destroy;
1375		}
1376
1377	0	subelement.local = "J";
1378	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1379
1380	0	result = ds_CryptoBinary_deserialize_pointer(
1381		&subelement,
1382		&instance->J,
1383		message_handle,
1384		0);
1385	0	if(result != GLOBUS_SUCCESS)
1386		{
1387	0	result = GlobusSoapMessageErrorDeserializeFailed(
1388		result,
1389		(&subelement));
1390	0	goto J_destroy_pointer;
1391		}
1392
1393	0	subelement.local = "Seed";
1394	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1395
1396	0	result = ds_CryptoBinary_deserialize(
1397		&subelement,
1398		&instance->Seed,
1399		message_handle,
1400		0);
1401	0	if(result != GLOBUS_SUCCESS)
1402		{
1403	0	result = GlobusSoapMessageErrorDeserializeFailed(
1404		result,
1405		&ds_CryptoBinary_qname);
1406	0	goto Seed_destroy;
1407		}
1408
1409	0	subelement.local = "PgenCounter";
1410	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
1411
1412	0	result = ds_CryptoBinary_deserialize(
1413		&subelement,
1414		&instance->PgenCounter,
1415		message_handle,
1416		0);
1417	0	if(result != GLOBUS_SUCCESS)
1418		{
1419	0	result = GlobusSoapMessageErrorDeserializeFailed(
1420		result,
1421		&ds_CryptoBinary_qname);
1422	0	goto PgenCounter_destroy;
1423		}
1424
1425
1426	0	result = globus_soap_message_deserialize_element_end(
1427		message_handle,
1428		element_qname);
1429	0	if(result != GLOBUS_SUCCESS)
1430		{
1431	0	result = GlobusSoapMessageErrorDeserializeFailed(
1432		result, element_qname);
1433	0	goto fail_deserialize;
1434		}
1435
1436	0	*ip = instance;
1437
1438	0	goto exit;
1439
1440		fail_deserialize:
1441	0	ds_CryptoBinary_destroy_contents(
1442		&instance->PgenCounter);
1443
1444		PgenCounter_destroy:
1445	0	ds_CryptoBinary_destroy_contents(
1446		&instance->Seed);
1447
1448		Seed_destroy:
1449	0	ds_CryptoBinary_destroy(
1450		instance->J);
1451	0	instance->J = NULL;
1452
1453		J_destroy_pointer:
1454	0	ds_CryptoBinary_destroy_contents(
1455		&instance->Y);
1456
1457		Y_destroy:
1458	0	ds_CryptoBinary_destroy(
1459		instance->G);
1460	0	instance->G = NULL;
1461
1462		G_destroy_pointer:
1463	0	ds_CryptoBinary_destroy_contents(
1464		&instance->Q);
1465
1466		Q_destroy:
1467	0	ds_CryptoBinary_destroy_contents(
1468		&instance->P);
1469
1470		P_destroy:
1471
1472		exit:
1473
1474	0	GlobusSoapMessageDebugExit();
1475	0	return result;
1476		}
1477
1478
1479		globus_result_t
1480		ds_DSAKeyValueType_array_init_contents(
1481		ds_DSAKeyValueType_array * array)
1482	0	{
1483	0	GlobusFuncName(ds_DSAKeyValueType_array_init_contents);
1484	0	GlobusSoapMessageDebugEnter();
1485
1486	0	memset(array, 0, sizeof(ds_DSAKeyValueType_array));
1487
1488	0	GlobusSoapMessageDebugExit();
1489	0	return GLOBUS_SUCCESS;
1490		}
1491
1492		globus_result_t
1493		ds_DSAKeyValueType_array_init(
1494		ds_DSAKeyValueType_array ** arr)
1495	0	{
1496	0	ds_DSAKeyValueType_array * array;
1497	0	globus_result_t                     result;
1498	0	GlobusFuncName(ds_DSAKeyValueType_array_init);
1499	0	GlobusSoapMessageDebugEnter();
1500
1501	0	array = (ds_DSAKeyValueType_array *)
1502		globus_malloc(sizeof(ds_DSAKeyValueType_array));
1503	0	if(!array)
1504		{
1505	0	result = GlobusSoapMessageErrorOutOfMemory;
1506	0	goto exit;
1507		}
1508
1509	0	result = ds_DSAKeyValueType_array_init_contents(array);
1510	0	if(result != GLOBUS_SUCCESS)
1511		{
1512	0	globus_free(array);
1513	0	array = NULL;
1514
1515		}
1516
1517	0	*arr = array;
1518
1519		exit:
1520	0	GlobusSoapMessageDebugExit();
1521	0	return result;
1522		}
1523
1524		void
1525		ds_DSAKeyValueType_array_destroy_contents(
1526		ds_DSAKeyValueType_array * array)
1527	0	{
1528	0	int                                 i = 0;
1529	0	GlobusFuncName(ds_DSAKeyValueType_array_destroy_contents);
1530	0	GlobusSoapMessageDebugEnter();
1531
1532	0	for(; i < array->length; ++i)
1533		{
1534	0	ds_DSAKeyValueType_destroy_contents(&array->elements[i]);
1535		}
1536
1537	0	if(array->elements)
1538		{
1539	0	globus_free(array->elements);
1540	0	array->elements = NULL;
1541		}
1542	0	array->length = 0;
1543
1544	0	GlobusSoapMessageDebugExit();
1545		}
1546
1547		void
1548		ds_DSAKeyValueType_array_destroy(
1549		ds_DSAKeyValueType_array * array)
1550	0	{
1551	0	GlobusFuncName(ds_DSAKeyValueType_array_destroy);
1552	0	GlobusSoapMessageDebugEnter();
1553
1554	0	ds_DSAKeyValueType_array_destroy_contents(array);
1555	0	globus_free(array);
1556
1557	0	GlobusSoapMessageDebugExit();
1558		}
1559
1560		globus_result_t
1561		ds_DSAKeyValueType_array_copy(
1562		ds_DSAKeyValueType_array ** dest_arr,
1563		const ds_DSAKeyValueType_array * src_arr)
1564	0	{
1565	0	ds_DSAKeyValueType_array * array;
1566	0	globus_result_t                     result;
1567	0	GlobusFuncName(ds_DSAKeyValueType_array_copy);
1568	0	GlobusSoapMessageDebugEnter();
1569
1570	0	array = (ds_DSAKeyValueType_array *) globus_malloc(
1571		sizeof(ds_DSAKeyValueType_array));
1572	0	if(!array)
1573		{
1574	0	result = GlobusSoapMessageErrorOutOfMemory;
1575	0	GlobusSoapMessageDebugExit();
1576	0	return result;
1577		}
1578
1579	0	result = ds_DSAKeyValueType_array_copy_contents(array, src_arr);
1580	0	if(result != GLOBUS_SUCCESS)
1581		{
1582	0	globus_free(array);
1583	0	GlobusSoapMessageDebugExit();
1584	0	return result;
1585		}
1586
1587	0	*dest_arr = array;
1588
1589	0	GlobusSoapMessageDebugExit();
1590	0	return GLOBUS_SUCCESS;
1591		}
1592
1593		globus_result_t
1594		ds_DSAKeyValueType_array_copy_contents(
1595		ds_DSAKeyValueType_array * dest_arr,
1596		const ds_DSAKeyValueType_array * src_arr)
1597	0	{
1598	0	int                                 i;
1599	0	globus_result_t                     result = GLOBUS_SUCCESS;
1600	0	GlobusFuncName(ds_DSAKeyValueType_array_copy_contents);
1601	0	GlobusSoapMessageDebugEnter();
1602
1603	0	dest_arr->length = src_arr->length;
1604	0	if(dest_arr->length > 0)
1605		{
1606	0	dest_arr->elements = (ds_DSAKeyValueType *) malloc(
1607		sizeof(ds_DSAKeyValueType) * dest_arr->length);
1608	0	if(!dest_arr->elements)
1609		{
1610	0	result = GlobusSoapMessageErrorOutOfMemory;
1611	0	GlobusSoapMessageDebugExit();
1612	0	return result;
1613		}
1614		}
1615		else
1616		{
1617	0	dest_arr->elements = NULL;
1618		}
1619
1620	0	for(i = 0; i < dest_arr->length; i++)
1621		{
1622	0	result = ds_DSAKeyValueType_copy_contents(
1623		&dest_arr->elements[i], &src_arr->elements[i]);
1624	0	if(result != GLOBUS_SUCCESS)
1625		{
1626	0	while(i--)
1627		{
1628	0	ds_DSAKeyValueType_destroy_contents(&dest_arr->elements[i]);
1629		}
1630
1631	0	globus_free(dest_arr->elements);
1632	0	dest_arr->elements = NULL;
1633	0	dest_arr->length = 0;
1634	0	break;
1635		}
1636		}
1637
1638	0	GlobusSoapMessageDebugExit();
1639	0	return result;
1640		}
1641
1642		ds_DSAKeyValueType *
1643		ds_DSAKeyValueType_array_push(
1644		ds_DSAKeyValueType_array * array)
1645	0	{
1646	0	GlobusFuncName(ds_DSAKeyValueType_array_push);
1647	0	GlobusSoapMessageDebugEnter();
1648
1649	0	array->elements = realloc(array->elements,
1650		sizeof(ds_DSAKeyValueType) *
1651		(array->length + 1));
1652	0	memset(&array->elements[array->length], 0, sizeof(ds_DSAKeyValueType));
1653	0	array->length++;
1654
1655	0	GlobusSoapMessageDebugExit();
1656	0	return (&array->elements[array->length - 1]);
1657		}
1658
1659		void *
1660		ds_DSAKeyValueType_array_push_wrapper(
1661		void * array)
1662	0	{
1663	0	return (void *) ds_DSAKeyValueType_array_push((ds_DSAKeyValueType_array *) array);
1664		}
1665
1666		globus_result_t
1667		ds_DSAKeyValueType_array_serialize(
1668		xsd_QName *                         element_qname,
1669		ds_DSAKeyValueType_array * array,
1670		globus_soap_message_handle_t        message,
1671		globus_xsd_element_options_t        options)
1672	0	{
1673	0	globus_result_t                     result = GLOBUS_SUCCESS;
1674	0	int                                 i = 0;
1675	0	GlobusFuncName(ds_DSAKeyValueType_array_serialize);
1676	0	GlobusSoapMessageDebugEnter();
1677
1678	0	for(; i < array->length; ++i)
1679		{
1680	0	result = ds_DSAKeyValueType_serialize(
1681		element_qname,
1682		&array->elements[i],
1683		message,
1684		options);
1685	0	if(result != GLOBUS_SUCCESS)
1686		{
1687	0	goto exit;
1688		}
1689		}
1690
1691		exit:
1692
1693	0	GlobusSoapMessageDebugExit();
1694	0	return result;
1695		}
1696
1697		globus_result_t
1698		ds_DSAKeyValueType_array_deserialize(
1699		xsd_QName *                         element_qname,
1700		ds_DSAKeyValueType_array * array,
1701		globus_soap_message_handle_t        message,
1702		globus_xsd_element_options_t        options)
1703	0	{
1704	0	globus_result_t                     result = GLOBUS_SUCCESS;
1705	0	int                                 i = 0;
1706	0	int                                 pre_length;
1707	0	GlobusFuncName(ds_DSAKeyValueType_array_deserialize);
1708	0	GlobusSoapMessageDebugEnter();
1709
1710	0	pre_length = array->length;
1711
1712	0	for(i = 0; i < pre_length; ++i)
1713		{
1714	0	result = ds_DSAKeyValueType_deserialize(
1715		element_qname,
1716		&array->elements[i],
1717		message,
1718		options);
1719	0	if(result != GLOBUS_SUCCESS)
1720		{
1721	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1722		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1723		GlobusSoapMessageStatusFailedWithTextCheck(result))
1724		{
1725	0	result = GLOBUS_SUCCESS;
1726	0	break;
1727		}
1728
1729	0	result = GlobusSoapMessageErrorDeserializeFailed(
1730		result, element_qname);
1731	0	goto exit;
1732		}
1733		}
1734
1735	0	while(result == GLOBUS_SUCCESS)
1736		{
1737	0	ds_DSAKeyValueType                  next;
1738	0	memset(&next, 0, sizeof(ds_DSAKeyValueType));
1739
1740	0	result = ds_DSAKeyValueType_deserialize(
1741		element_qname,
1742		&next,
1743		message,
1744		options);
1745	0	if(result != GLOBUS_SUCCESS)
1746		{
1747	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1748		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1749		GlobusSoapMessageStatusFailedWithTextCheck(result))
1750		{
1751	0	result = GLOBUS_SUCCESS;
1752	0	break;
1753		}
1754
1755	0	result = GlobusSoapMessageErrorDeserializeFailed(
1756		result, element_qname);
1757	0	goto exit;
1758		}
1759
1760	0	array->elements = realloc(
1761		array->elements,
1762		(array->length + 1) * sizeof(ds_DSAKeyValueType));
1763	0	if(!array->elements)
1764		{
1765	0	result = GlobusSoapMessageErrorOutOfMemory;
1766	0	goto exit;
1767		}
1768	0	array->elements[array->length] = next;
1769	0	array->length++;
1770	0	++i;
1771		}
1772
1773		exit:
1774
1775	0	if(result != GLOBUS_SUCCESS)
1776		{
1777	0	int                             di = 0;
1778	0	for(; di < i; ++di)
1779		{
1780	0	ds_DSAKeyValueType_destroy_contents(
1781		&array->elements[di]);
1782	0	memset(&array->elements[di], 0, sizeof(ds_DSAKeyValueType));
1783		}
1784		}
1785
1786	0	GlobusSoapMessageDebugExit();
1787	0	return result;