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_CryptoBinary.h"
21
22		xsd_QName ds_CryptoBinary_qname =
23		{
24		"http://www.w3.org/2000/09/xmldsig#",
25		"CryptoBinary"
26		};
27
28		globus_result_t
29		ds_CryptoBinary_serialize_wrapper(
30		xsd_QName * element_qname,
31		void * instance,
32		globus_soap_message_handle_t message_handle,
33		globus_xsd_element_options_t options)
34	0	{
35	0	return ds_CryptoBinary_serialize(
36		element_qname,
37		(ds_CryptoBinary *) instance,
38		message_handle, options);
39		}
40
41		globus_result_t
42		ds_CryptoBinary_deserialize_pointer_wrapper(
43		xsd_QName * element_qname,
44		void ** ip,
45		globus_soap_message_handle_t message_handle,
46		globus_xsd_element_options_t options)
47	0	{
48	0	return ds_CryptoBinary_deserialize_pointer(
49		element_qname,
50		(ds_CryptoBinary **) ip,
51		message_handle, options);
52		}
53
54		globus_result_t
55		ds_CryptoBinary_init_wrapper(void **object)
56	0	{
57	0	return ds_CryptoBinary_init(
58		(ds_CryptoBinary **) object);
59		}
60
61		void
62		ds_CryptoBinary_destroy_wrapper(
63		void * object)
64	0	{
65	0	ds_CryptoBinary_destroy(
66		(ds_CryptoBinary *) object);
67		}
68
69		globus_result_t
70		ds_CryptoBinary_copy_wrapper(
71		void ** dest_obj,
72		void * src_obj)
73	0	{
74	0	return ds_CryptoBinary_copy(
75		(ds_CryptoBinary **) dest_obj,
76		(ds_CryptoBinary *) src_obj);
77		}
78
79		globus_result_t
80		ds_CryptoBinary_init_contents_wrapper(void *object)
81	0	{
82	0	return ds_CryptoBinary_init_contents(
83		(ds_CryptoBinary *) object);
84		}
85
86		void
87		ds_CryptoBinary_destroy_contents_wrapper(
88		void * object)
89	0	{
90	0	ds_CryptoBinary_destroy_contents(
91		(ds_CryptoBinary *) object);
92		}
93
94		globus_result_t
95		ds_CryptoBinary_copy_contents_wrapper(
96		void * dest_obj,
97		void * src_obj)
98	0	{
99	0	return ds_CryptoBinary_copy_contents(
100		(ds_CryptoBinary *) dest_obj,
101		(ds_CryptoBinary *) src_obj);
102		}
103
104		globus_result_t
105		ds_CryptoBinary_serialize_contents_wrapper(
106		xsd_QName * element_qname,
107		void * instance,
108		globus_soap_message_handle_t message_handle,
109		globus_xsd_element_options_t options)
110	0	{
111	0	return ds_CryptoBinary_serialize_contents(
112		element_qname,
113		(ds_CryptoBinary *) instance,
114		message_handle, options);
115		}
116
117		globus_result_t
118		ds_CryptoBinary_deserialize_contents_wrapper(
119		xsd_QName * element_qname,
120		void ** instance,
121		globus_soap_message_handle_t message_handle,
122		globus_xsd_element_options_t options)
123	0	{
124		globus_result_t result;
125		GlobusFuncName(ds_CryptoBinary_deserialize_contents_wrapper);
126	0	GlobusSoapMessageDebugEnter();
127
128	0	if(!*instance)
129		{
130	0	result = ds_CryptoBinary_init(
131		(ds_CryptoBinary **)instance);
132	0	if(result != GLOBUS_SUCCESS)
133		{
134	0	goto error;
135		}
136		}
137
138	0	result = ds_CryptoBinary_deserialize_contents(
139		element_qname,
140		*(ds_CryptoBinary **)instance,
141		message_handle, options);
142	0	error:
143	0	GlobusSoapMessageDebugExit();
144	0	return result;
145		}
146
147		globus_result_t
148		ds_CryptoBinary_array_serialize_wrapper(
149		xsd_QName * element,
150		void * instance,
151		globus_soap_message_handle_t message,
152		globus_xsd_element_options_t options)
153	0	{
154	0	return ds_CryptoBinary_array_serialize(
155		element,
156		(ds_CryptoBinary_array *) instance,
157		message, options);
158		}
159
160		globus_result_t
161		ds_CryptoBinary_array_deserialize_wrapper(
162		xsd_QName * element_qname,
163		void ** inst,
164		globus_soap_message_handle_t message,
165		globus_xsd_element_options_t options)
166	0	{
167	0	if(!*inst)
168		{
169		globus_result_t result;
170
171	0	result = ds_CryptoBinary_array_init(
172		(ds_CryptoBinary_array **)inst);
173	0	if(result != GLOBUS_SUCCESS)
174		{
175	0	return result;
176		}
177		}
178
179	0	return ds_CryptoBinary_array_deserialize(
180		element_qname,
181		*(ds_CryptoBinary_array **) inst,
182		message, options);
183		}
184
185		globus_result_t
186		ds_CryptoBinary_array_init_wrapper(
187		void ** arr)
188	0	{
189	0	return ds_CryptoBinary_array_init(
190		(ds_CryptoBinary_array **) arr);
191		}
192
193		void
194		ds_CryptoBinary_array_destroy_wrapper(
195		void * arr)
196	0	{
197	0	ds_CryptoBinary_array_destroy(
198		(ds_CryptoBinary_array *) arr);
199		}
200
201		globus_result_t
202		ds_CryptoBinary_array_copy_wrapper(
203		void ** dest_arr,
204		void * src_arr)
205	0	{
206	0	return ds_CryptoBinary_array_copy(
207		(ds_CryptoBinary_array **) dest_arr,
208		(ds_CryptoBinary_array *) src_arr);
209		}
210		globus_result_t
211		ds_CryptoBinary_array_init_contents_wrapper(
212		void * arr)
213	0	{
214	0	return ds_CryptoBinary_array_init_contents(
215		(ds_CryptoBinary_array *) arr);
216		}
217
218		void
219		ds_CryptoBinary_array_destroy_contents_wrapper(
220		void * arr)
221	0	{
222	0	ds_CryptoBinary_array_destroy_contents(
223		(ds_CryptoBinary_array *) arr);
224		}
225
226		globus_result_t
227		ds_CryptoBinary_array_copy_contents_wrapper(
228		void * dest_arr,
229		void * src_arr)
230	0	{
231	0	return ds_CryptoBinary_array_copy_contents(
232		(ds_CryptoBinary_array *) dest_arr,
233		(ds_CryptoBinary_array *) src_arr);
234		}
235
236		struct globus_xsd_type_info_s ds_CryptoBinary_array_info =
237		{
238		&ds_CryptoBinary_qname,
239		ds_CryptoBinary_array_serialize_wrapper,
240		ds_CryptoBinary_array_deserialize_wrapper,
241		ds_CryptoBinary_array_init_wrapper,
242		ds_CryptoBinary_array_destroy_wrapper,
243		ds_CryptoBinary_array_copy_wrapper,
244		ds_CryptoBinary_array_init_contents_wrapper,
245		ds_CryptoBinary_array_destroy_contents_wrapper,
246		ds_CryptoBinary_array_copy_contents_wrapper,
247		sizeof(ds_CryptoBinary),
248		ds_CryptoBinary_array_push_wrapper,
249		NULL,
250		NULL
251		};
252
253		struct globus_xsd_type_info_s ds_CryptoBinary_contents_info =
254		{
255		&ds_CryptoBinary_qname,
256		ds_CryptoBinary_serialize_contents_wrapper,
257		ds_CryptoBinary_deserialize_contents_wrapper,
258		ds_CryptoBinary_init_wrapper,
259		ds_CryptoBinary_destroy_wrapper,
260		ds_CryptoBinary_copy_wrapper,
261		ds_CryptoBinary_init_contents_wrapper,
262		ds_CryptoBinary_destroy_contents_wrapper,
263		ds_CryptoBinary_copy_contents_wrapper,
264		sizeof(ds_CryptoBinary),
265		NULL,
266		NULL,
267		NULL
268		};
269
270		struct globus_xsd_type_info_s ds_CryptoBinary_info =
271		{
272		&ds_CryptoBinary_qname,
273		ds_CryptoBinary_serialize_wrapper,
274		ds_CryptoBinary_deserialize_pointer_wrapper,
275		ds_CryptoBinary_init_wrapper,
276		ds_CryptoBinary_destroy_wrapper,
277		ds_CryptoBinary_copy_wrapper,
278		ds_CryptoBinary_init_contents_wrapper,
279		ds_CryptoBinary_destroy_contents_wrapper,
280		ds_CryptoBinary_copy_contents_wrapper,
281		sizeof(ds_CryptoBinary),
282		NULL,
283		&ds_CryptoBinary_contents_info,
284		&ds_CryptoBinary_array_info
285		};
286
287		globus_result_t
288		ds_CryptoBinary_init_contents(
289		ds_CryptoBinary * instance)
290	0	{
291	0	globus_result_t result = GLOBUS_SUCCESS;
292		GlobusFuncName(ds_CryptoBinary_init_contents);
293	0	GlobusSoapMessageDebugEnter();
294
295
296	0	xsd_base64Binary_init_contents(instance);
297
298	0	GlobusSoapMessageDebugExit();
299	0	return result;
300		}
301
302		globus_result_t
303		ds_CryptoBinary_init(
304		ds_CryptoBinary ** object)
305	0	{
306		ds_CryptoBinary * instance;
307	0	globus_result_t result = GLOBUS_SUCCESS;
308		GlobusFuncName(ds_CryptoBinary_init);
309	0	GlobusSoapMessageDebugEnter();
310
311
312	0	xsd_base64Binary_init(object);
313
314	0	GlobusSoapMessageDebugExit();
315	0	return result;
316		}
317
318		void
319		ds_CryptoBinary_destroy(
320		ds_CryptoBinary * instance)
321	0	{
322		GlobusFuncName(ds_CryptoBinary_destroy);
323	0	GlobusSoapMessageDebugEnter();
324
325	0	if(!instance)
326		{
327	0	goto exit;
328		}
329
330	0	ds_CryptoBinary_destroy_contents(instance);
331	0	globus_free(instance);
332
333	0	exit:
334
335	0	GlobusSoapMessageDebugExit();
336		}
337
338		void
339		ds_CryptoBinary_destroy_contents(
340		ds_CryptoBinary * instance)
341	0	{
342		GlobusFuncName(ds_CryptoBinary_destroy_contents);
343	0	GlobusSoapMessageDebugEnter();
344
345	0	if(instance)
346		{
347
348
349	0	xsd_base64Binary_destroy_contents(instance);
350
351		}
352
353	0	GlobusSoapMessageDebugExit();
354		}
355
356		globus_result_t
357		ds_CryptoBinary_copy(
358		ds_CryptoBinary ** dest_obj,
359		const ds_CryptoBinary * src_obj)
360	0	{
361	0	globus_result_t result = GLOBUS_SUCCESS;
362		ds_CryptoBinary * instance;
363		GlobusFuncName(ds_CryptoBinary_copy);
364
365	0	GlobusSoapMessageDebugEnter();
366
367	0	instance = malloc(sizeof(ds_CryptoBinary));
368	0	if (instance == NULL)
369		{
370	0	GlobusSoapMessageDebugExit();
371	0	return GlobusSoapMessageErrorOutOfMemory;
372		}
373
374	0	result = ds_CryptoBinary_copy_contents(instance, src_obj);
375	0	if(result != GLOBUS_SUCCESS)
376		{
377	0	globus_free(instance);
378	0	GlobusSoapMessageDebugExit();
379	0	return GlobusSoapMessageErrorOutOfMemory;
380		}
381
382	0	*dest_obj = instance;
383	0	GlobusSoapMessageDebugExit();
384	0	return result;
385		}
386
387		globus_result_t
388		ds_CryptoBinary_copy_contents(
389		ds_CryptoBinary * instance,
390		const ds_CryptoBinary * src_obj)
391	0	{
392	0	globus_result_t result = GLOBUS_SUCCESS;
393		GlobusFuncName(ds_CryptoBinary_copy_contents);
394
395	0	GlobusSoapMessageDebugEnter();
396
397
398	0	result = xsd_base64Binary_copy_contents(
399		instance, src_obj);
400
401		goto exit;
402
403	0	fail_copy:
404
405
406	0	exit:
407
408	0	GlobusSoapMessageDebugExit();
409	0	return result;
410		}
411
412
413
414		globus_result_t
415		ds_CryptoBinary_serialize_contents(
416		xsd_QName * element_qname, /* ignored */
417		ds_CryptoBinary * inst,
418		globus_soap_message_handle_t message_handle,
419		globus_xsd_element_options_t options)
420	0	{
421	0	globus_result_t result = GLOBUS_SUCCESS;
422		GlobusFuncName(ds_CryptoBinary_serialize_contents);
423	0	GlobusSoapMessageDebugEnter();
424
425	0	result = ds_CryptoBinary_serialize(
426		NULL,
427		inst,
428		message_handle,
429		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
430	0	if(result != GLOBUS_SUCCESS)
431		{
432	0	result = GlobusSoapMessageErrorSerializeFailed(
433		result, NULL, element_qname);
434		goto exit;
435		}
436
437	0	exit:
438
439	0	GlobusSoapMessageDebugExit();
440	0	return result;
441		}
442
443
444
445		globus_result_t
446		ds_CryptoBinary_serialize(
447		xsd_QName * element_qname,
448		ds_CryptoBinary * instance,
449		globus_soap_message_handle_t message_handle,
450		globus_xsd_element_options_t options)
451	0	{
452	0	globus_result_t result = GLOBUS_SUCCESS;
453		xsd_QName subelement;
454	0	globus_list_t * any_attr_keys = NULL;
455	0	globus_list_t * any_attr_keys_iterator = NULL;
456	0	xsd_QName * type_attr = NULL;
457	0	char * type_value = NULL;
458	0	char * prefix = NULL;
459		int prefix_created;
460	0	int define_prefix = 0;
461	0	char * type_attr_prefix = NULL;
462
463		GlobusFuncName(ds_CryptoBinary_serialize);
464	0	GlobusSoapMessageDebugEnter();
465
466
467	0	result = xsd_base64Binary_serialize(
468		element_qname,
469		instance,
470		message_handle,
471		options);
472
473	0	exit:
474
475	0	if(any_attr_keys)
476		{
477	0	globus_list_free(any_attr_keys);
478		}
479
480	0	GlobusSoapMessageDebugExit();
481	0	return result;
482		}
483
484
485
486		globus_result_t
487		ds_CryptoBinary_deserialize_contents(
488		xsd_QName * element_qname, /* ignored */
489		ds_CryptoBinary * inst,
490		globus_soap_message_handle_t message_handle,
491		globus_xsd_element_options_t options)
492	0	{
493	0	globus_result_t result = GLOBUS_SUCCESS;
494		GlobusFuncName(ds_CryptoBinary_deserialize_contents);
495	0	GlobusSoapMessageDebugEnter();
496
497	0	result = ds_CryptoBinary_deserialize(
498		NULL,
499		inst,
500		message_handle,
501		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
502	0	if(result != GLOBUS_SUCCESS)
503		{
504	0	result = GlobusSoapMessageErrorDeserializeFailed(
505		result, element_qname);
506		goto exit;
507		}
508
509	0	exit:
510
511	0	GlobusSoapMessageDebugExit();
512	0	return result;
513		}
514
515
516
517		globus_result_t
518		ds_CryptoBinary_deserialize(
519		xsd_QName * element_qname,
520		ds_CryptoBinary * instance,
521		globus_soap_message_handle_t message_handle,
522		globus_xsd_element_options_t options)
523	0	{
524	0	globus_result_t result = GLOBUS_SUCCESS;
525		xsd_QName subelement;
526		GlobusFuncName(ds_CryptoBinary_deserialize);
527	0	GlobusSoapMessageDebugEnter();
528
529
530	0	result = xsd_base64Binary_deserialize(element_qname,
531		instance, message_handle, options);
532
533
534	0	exit:
535
536	0	GlobusSoapMessageDebugExit();
537	0	return result;
538		}
539
540
541
542		globus_result_t
543		ds_CryptoBinary_deserialize_pointer(
544		xsd_QName * element_qname,
545		ds_CryptoBinary ** ip,
546		globus_soap_message_handle_t message_handle,
547		globus_xsd_element_options_t options)
548	0	{
549	0	ds_CryptoBinary * instance = NULL;
550	0	globus_result_t result = GLOBUS_SUCCESS;
551		xsd_QName subelement;
552		GlobusFuncName(ds_CryptoBinary_deserialize_pointer);
553	0	GlobusSoapMessageDebugEnter();
554
555	0	*ip = NULL;
556
557
558	0	result = xsd_base64Binary_deserialize_pointer(
559		element_qname,
560		ip, message_handle, options);
561
562
563	0	exit:
564
565	0	GlobusSoapMessageDebugExit();
566	0	return result;
567		}
568
569
570
571		globus_result_t
572		ds_CryptoBinary_array_init_contents(
573		ds_CryptoBinary_array * array)
574	0	{
575		GlobusFuncName(ds_CryptoBinary_array_init_contents);
576	0	GlobusSoapMessageDebugEnter();
577
578	0	memset(array, 0, sizeof(ds_CryptoBinary_array));
579
580	0	GlobusSoapMessageDebugExit();
581	0	return GLOBUS_SUCCESS;
582		}
583
584		globus_result_t
585		ds_CryptoBinary_array_init(
586		ds_CryptoBinary_array ** arr)
587	0	{
588		ds_CryptoBinary_array * array;
589		globus_result_t result;
590		GlobusFuncName(ds_CryptoBinary_array_init);
591	0	GlobusSoapMessageDebugEnter();
592
593	0	array = (ds_CryptoBinary_array *)
594		globus_malloc(sizeof(ds_CryptoBinary_array));
595	0	if(!array)
596		{
597	0	result = GlobusSoapMessageErrorOutOfMemory;
598	0	GlobusSoapMessageDebugExit();
599	0	return result;
600		}
601
602	0	result = ds_CryptoBinary_array_init_contents(array);
603	0	if(result != GLOBUS_SUCCESS)
604		{
605	0	globus_free(array);
606	0	array = NULL;
607
608		}
609
610	0	*arr = array;
611
612	0	GlobusSoapMessageDebugExit();
613	0	return result;
614		}
615
616		void
617		ds_CryptoBinary_array_destroy_contents(
618		ds_CryptoBinary_array * array)
619	0	{
620	0	int i = 0;
621		GlobusFuncName(ds_CryptoBinary_array_destroy_contents);
622	0	GlobusSoapMessageDebugEnter();
623
624	0	for(; i < array->length; ++i)
625		{
626	0	ds_CryptoBinary_destroy_contents(&array->elements[i]);
627		}
628
629	0	if(array->elements)
630		{
631	0	globus_free(array->elements);
632	0	array->elements = NULL;
633		}
634	0	array->length = 0;
635
636	0	GlobusSoapMessageDebugExit();
637		}
638
639		void
640		ds_CryptoBinary_array_destroy(
641		ds_CryptoBinary_array * array)
642	0	{
643		GlobusFuncName(ds_CryptoBinary_array_destroy);
644	0	GlobusSoapMessageDebugEnter();
645
646	0	ds_CryptoBinary_array_destroy_contents(array);
647	0	globus_free(array);
648
649	0	GlobusSoapMessageDebugExit();
650		}
651
652		globus_result_t
653		ds_CryptoBinary_array_copy(
654		ds_CryptoBinary_array ** dest_arr,
655		const ds_CryptoBinary_array * src_arr)
656	0	{
657		ds_CryptoBinary_array * array;
658		globus_result_t result;
659		GlobusFuncName(ds_CryptoBinary_array_copy);
660	0	GlobusSoapMessageDebugEnter();
661
662	0	array = (ds_CryptoBinary_array *) malloc(
663		sizeof(ds_CryptoBinary_array));
664	0	if(!array)
665		{
666	0	result = GlobusSoapMessageErrorOutOfMemory;
667	0	GlobusSoapMessageDebugExit();
668	0	return result;
669		}
670
671	0	result = ds_CryptoBinary_array_copy_contents(array, src_arr);
672	0	if(result != GLOBUS_SUCCESS)
673		{
674	0	globus_free(array);
675	0	GlobusSoapMessageDebugExit();
676	0	return result;
677		}
678
679	0	*dest_arr = array;
680
681	0	GlobusSoapMessageDebugExit();
682	0	return GLOBUS_SUCCESS;
683		}
684
685		globus_result_t
686		ds_CryptoBinary_array_copy_contents(
687		ds_CryptoBinary_array * dest_arr,
688		const ds_CryptoBinary_array * src_arr)
689	0	{
690		int i;
691	0	globus_result_t result = GLOBUS_SUCCESS;
692		GlobusFuncName(ds_CryptoBinary_array_copy_contents);
693	0	GlobusSoapMessageDebugEnter();
694
695	0	dest_arr->length = src_arr->length;
696	0	if(dest_arr->length > 0)
697		{
698	0	dest_arr->elements = (ds_CryptoBinary *) malloc(
699		sizeof(ds_CryptoBinary) * dest_arr->length);
700	0	if(!dest_arr->elements)
701		{
702	0	result = GlobusSoapMessageErrorOutOfMemory;
703	0	GlobusSoapMessageDebugExit();
704	0	return result;
705		}
706		}
707		else
708		{
709	0	dest_arr->elements = NULL;
710		}
711
712	0	for(i = 0; i < dest_arr->length; i++)
713		{
714	0	result = ds_CryptoBinary_copy_contents(
715		&dest_arr->elements[i], &src_arr->elements[i]);
716	0	if(result != GLOBUS_SUCCESS)
717		{
718	0	while(i--)
719		{
720	0	ds_CryptoBinary_destroy_contents(&dest_arr->elements[i]);
721		}
722
723	0	globus_free(dest_arr->elements);
724	0	dest_arr->elements = NULL;
725	0	dest_arr->length = 0;
726	0	break;
727		}
728		}
729
730	0	GlobusSoapMessageDebugExit();
731	0	return result;
732		}
733
734		ds_CryptoBinary *
735		ds_CryptoBinary_array_push(
736		ds_CryptoBinary_array * array)
737	0	{
738		GlobusFuncName(ds_CryptoBinary_array_push);
739	0	GlobusSoapMessageDebugEnter();
740
741	0	array->elements = realloc(array->elements,
742		sizeof(ds_CryptoBinary) *
743		(array->length + 1));
744	0	memset(&array->elements[array->length], 0, sizeof(ds_CryptoBinary));
745	0	array->length++;
746
747	0	GlobusSoapMessageDebugExit();
748	0	return (&array->elements[array->length - 1]);
749		}
750
751		void *
752		ds_CryptoBinary_array_push_wrapper(
753		void * array)
754	0	{
755	0	return (void *) ds_CryptoBinary_array_push((ds_CryptoBinary_array *) array);
756		}
757
758		globus_result_t
759		ds_CryptoBinary_array_serialize(
760		xsd_QName * element_qname,
761		ds_CryptoBinary_array * array,
762		globus_soap_message_handle_t message,
763		globus_xsd_element_options_t options)
764	0	{
765	0	globus_result_t result = GLOBUS_SUCCESS;
766	0	int i = 0;
767		GlobusFuncName(ds_CryptoBinary_array_serialize);
768	0	GlobusSoapMessageDebugEnter();
769
770	0	for(; i < array->length; ++i)
771		{
772	0	result = ds_CryptoBinary_serialize(
773		element_qname,
774		&array->elements[i],
775		message,
776		options);
777	0	if(result != GLOBUS_SUCCESS)
778		{
779	0	goto exit;
780		}
781		}
782
783	0	exit:
784
785	0	GlobusSoapMessageDebugExit();
786	0	return result;
787		}
788
789		globus_result_t
790		ds_CryptoBinary_array_deserialize(
791		xsd_QName * element_qname,
792		ds_CryptoBinary_array * array,
793		globus_soap_message_handle_t message,
794		globus_xsd_element_options_t options)
795	0	{
796	0	globus_result_t result = GLOBUS_SUCCESS;
797	0	int i = 0;
798		int pre_length;
799		GlobusFuncName(ds_CryptoBinary_array_deserialize);
800	0	GlobusSoapMessageDebugEnter();
801
802	0	pre_length = array->length;
803
804	0	for(i = 0; i < pre_length; ++i)
805		{
806	0	result = ds_CryptoBinary_deserialize(
807		element_qname,
808		&array->elements[i],
809		message,
810		options);
811	0	if(result != GLOBUS_SUCCESS)
812		{
813	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
814		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
815		GlobusSoapMessageStatusFailedWithTextCheck(result))
816		{
817	0	result = GLOBUS_SUCCESS;
818	0	break;
819		}
820
821	0	result = GlobusSoapMessageErrorDeserializeFailed(
822		result, element_qname);
823	0	goto exit;
824		}
825		}
826
827	0	while(result == GLOBUS_SUCCESS)
828		{
829		ds_CryptoBinary next;
830	0	memset(&next, 0, sizeof(ds_CryptoBinary));
831
832	0	result = ds_CryptoBinary_deserialize(
833		element_qname,
834		&next,
835		message,
836		options);
837	0	if(result != GLOBUS_SUCCESS)
838		{
839	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
840		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
841		GlobusSoapMessageStatusFailedWithTextCheck(result))
842		{
843	0	result = GLOBUS_SUCCESS;
844	0	break;
845		}
846
847	0	result = GlobusSoapMessageErrorDeserializeFailed(
848		result, element_qname);
849	0	goto exit;
850		}
851
852	0	array->elements = realloc(
853		array->elements,
854		(array->length + 1) * sizeof(ds_CryptoBinary));
855	0	if(!array->elements)
856		{
857	0	result = GlobusSoapMessageErrorOutOfMemory;
858	0	goto exit;
859		}
860	0	array->elements[array->length] = next;
861	0	array->length++;
862	0	++i;
863		}
864
865	0	exit:
866
867	0	if(result != GLOBUS_SUCCESS)
868		{
869	0	int di = 0;
870	0	for(; di < i; ++di)
871		{
872	0	ds_CryptoBinary_destroy_contents(
873		&array->elements[di]);
874	0	memset(&array->elements[di], 0, sizeof(ds_CryptoBinary));
875		}
876		}
877
878	0	GlobusSoapMessageDebugExit();
879	0	return result;
880		}
881
882
883		globus_result_t
884		ds_CryptoBinary_serialize_attribute(
885		xsd_QName * attr_qname,
886		ds_CryptoBinary * val,
887		globus_soap_message_handle_t handle,
888		globus_xsd_element_options_t options)
889	0	{
890	0	globus_result_t result = GLOBUS_SUCCESS;
891		GlobusFuncName(ds_CryptoBinary_serialize_attribute);
892	0	GlobusSoapMessageDebugEnter();
893
894
895	0	result = xsd_base64Binary_serialize_attribute(
896		attr_qname, (xsd_base64Binary *)val, handle, options);
897	0	if(result != GLOBUS_SUCCESS)
898		{
899	0	result = GlobusSoapMessageErrorSerializeFailed(
900		result, NULL, attr_qname);
901		goto exit;
902		}
903
904	0	exit:
905
906	0	GlobusSoapMessageDebugExit();
907	0	return result;
908		}
909
910		globus_result_t
911		ds_CryptoBinary_deserialize_attribute(
912		xsd_QName * attr_qname,
913		ds_CryptoBinary * instance,
914		globus_soap_message_handle_t message,
915		globus_xsd_element_options_t options)
916	0	{
917	0	globus_result_t result = GLOBUS_SUCCESS;
918		GlobusFuncName(ds_CryptoBinary_deserialize_attribute);
919	0	GlobusSoapMessageDebugEnter();
920
921
922	0	result = xsd_base64Binary_deserialize_attribute(
923		attr_qname, (xsd_base64Binary *)instance, message, options);
924
925	0	if(result != GLOBUS_SUCCESS)
926		{
927	0	result = GlobusSoapMessageErrorDeserializeFailed(
928		result, attr_qname);
929		goto exit;
930		}
931
932	0	exit:
933
934	0	GlobusSoapMessageDebugExit();
935	0	return result;
936		}
937
938		globus_result_t
939		ds_CryptoBinary_deserialize_attribute_pointer(
940		xsd_QName * attr_qname,
941		ds_CryptoBinary ** instance,
942		globus_soap_message_handle_t message,
943		globus_xsd_element_options_t options)
944	0	{
945	0	globus_result_t result = GLOBUS_SUCCESS;
946		GlobusFuncName(ds_CryptoBinary_deserialize_attribute_pointer);
947	0	GlobusSoapMessageDebugEnter();
948
949
950	0	result = xsd_base64Binary_deserialize_attribute_pointer(
951		attr_qname, (xsd_base64Binary **)instance, message, options);
952
953	0	if(result != GLOBUS_SUCCESS)
954		{
955	0	result = GlobusSoapMessageErrorDeserializeFailed(
956		result, attr_qname);
957		goto exit;
958		}
959
960	0	exit:
961
962	0	GlobusSoapMessageDebugExit();
963	0	return result;