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 "wst_BinarySecretType.h"
21
22		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
23		xsd_QName wst_BinarySecretType_qname =
24		{
25		WST_BINARYSECRETTYPE_NS,
26		WST_BINARYSECRETTYPE_LOCAL
27		};
28		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
29
30		globus_result_t
31		wst_BinarySecretType_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 wst_BinarySecretType_serialize(
38		element_qname,
39		(wst_BinarySecretType *) instance,
40		message_handle, options);
41		}
42
43		globus_result_t
44		wst_BinarySecretType_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 wst_BinarySecretType_deserialize_pointer(
51		element_qname,
52		(wst_BinarySecretType **) ip,
53		message_handle, options);
54		}
55
56		globus_result_t
57		wst_BinarySecretType_init_wrapper(void **object)
58	0	{
59	0	return wst_BinarySecretType_init(
60		(wst_BinarySecretType **) object);
61		}
62
63		void
64		wst_BinarySecretType_destroy_wrapper(
65		void *                          object)
66	0	{
67	0	wst_BinarySecretType_destroy(
68		(wst_BinarySecretType *) object);
69		}
70
71		globus_result_t
72		wst_BinarySecretType_copy_wrapper(
73		void **                         dest_obj,
74		void *                          src_obj)
75	0	{
76	0	return wst_BinarySecretType_copy(
77		(wst_BinarySecretType **) dest_obj,
78		(wst_BinarySecretType *) src_obj);
79		}
80
81		globus_result_t
82		wst_BinarySecretType_init_contents_wrapper(void *object)
83	0	{
84	0	return wst_BinarySecretType_init_contents(
85		(wst_BinarySecretType *) object);
86		}
87
88		void
89		wst_BinarySecretType_destroy_contents_wrapper(
90		void *                          object)
91	0	{
92	0	wst_BinarySecretType_destroy_contents(
93		(wst_BinarySecretType *) object);
94		}
95
96		globus_result_t
97		wst_BinarySecretType_copy_contents_wrapper(
98		void *                          dest_obj,
99		void *                          src_obj)
100	0	{
101	0	return wst_BinarySecretType_copy_contents(
102		(wst_BinarySecretType *) dest_obj,
103		(wst_BinarySecretType *) src_obj);
104		}
105
106		globus_result_t
107		wst_BinarySecretType_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 wst_BinarySecretType_serialize_contents(
114		element_qname,
115		(wst_BinarySecretType *) instance,
116		message_handle, options);
117		}
118
119		globus_result_t
120		wst_BinarySecretType_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(wst_BinarySecretType_deserialize_contents_wrapper);
128	0	GlobusSoapMessageDebugEnter();
129
130	0	if(!*instance)
131		{
132	0	result = wst_BinarySecretType_init(
133		(wst_BinarySecretType **)instance);
134	0	if(result != GLOBUS_SUCCESS)
135		{
136	0	goto error;
137		}
138		}
139
140	0	result = wst_BinarySecretType_deserialize_contents(
141		element_qname,
142		*(wst_BinarySecretType **)instance,
143		message_handle, options);
144		error:
145	0	GlobusSoapMessageDebugExit();
146	0	return result;
147		}
148
149		globus_result_t
150		wst_BinarySecretType_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 wst_BinarySecretType_array_serialize(
157		element,
158		(wst_BinarySecretType_array *) instance,
159		message, options);
160		}
161
162		globus_result_t
163		wst_BinarySecretType_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 = wst_BinarySecretType_array_init(
174		(wst_BinarySecretType_array **)inst);
175	0	if(result != GLOBUS_SUCCESS)
176		{
177	0	return result;
178		}
179		}
180
181	0	return wst_BinarySecretType_array_deserialize(
182		element_qname,
183		*(wst_BinarySecretType_array **) inst,
184		message, options);
185		}
186
187		globus_result_t
188		wst_BinarySecretType_array_init_wrapper(
189		void **                             arr)
190	0	{
191	0	return wst_BinarySecretType_array_init(
192		(wst_BinarySecretType_array **) arr);
193		}
194
195		void
196		wst_BinarySecretType_array_destroy_wrapper(
197		void *                              arr)
198	0	{
199	0	wst_BinarySecretType_array_destroy(
200		(wst_BinarySecretType_array *) arr);
201		}
202
203		globus_result_t
204		wst_BinarySecretType_array_copy_wrapper(
205		void **                             dest_arr,
206		void *                              src_arr)
207	0	{
208	0	return wst_BinarySecretType_array_copy(
209		(wst_BinarySecretType_array **) dest_arr,
210		(wst_BinarySecretType_array *) src_arr);
211		}
212
213		globus_result_t
214		wst_BinarySecretType_array_init_contents_wrapper(
215		void *                              arr)
216	0	{
217	0	return wst_BinarySecretType_array_init_contents(
218		(wst_BinarySecretType_array *) arr);
219		}
220
221		void
222		wst_BinarySecretType_array_destroy_contents_wrapper(
223		void *                              arr)
224	0	{
225	0	wst_BinarySecretType_array_destroy_contents(
226		(wst_BinarySecretType_array *) arr);
227		}
228
229		globus_result_t
230		wst_BinarySecretType_array_copy_contents_wrapper(
231		void *                              dest_arr,
232		void *                              src_arr)
233	0	{
234	0	return wst_BinarySecretType_array_copy_contents(
235		(wst_BinarySecretType_array *) dest_arr,
236		(wst_BinarySecretType_array *) src_arr);
237		}
238
239		struct globus_xsd_type_info_s wst_BinarySecretType_contents_info =
240		{
241		&wst_BinarySecretType_qname,
242		wst_BinarySecretType_serialize_contents_wrapper,
243		wst_BinarySecretType_deserialize_contents_wrapper,
244		wst_BinarySecretType_init_wrapper,
245		wst_BinarySecretType_destroy_wrapper,
246		wst_BinarySecretType_copy_wrapper,
247		wst_BinarySecretType_init_contents_wrapper,
248		wst_BinarySecretType_destroy_contents_wrapper,
249		wst_BinarySecretType_copy_contents_wrapper,
250		sizeof(wst_BinarySecretType),
251		NULL,
252		NULL,
253		NULL
254		};
255
256		struct globus_xsd_type_info_s wst_BinarySecretType_array_info =
257		{
258		&wst_BinarySecretType_qname,
259		wst_BinarySecretType_array_serialize_wrapper,
260		wst_BinarySecretType_array_deserialize_wrapper,
261		wst_BinarySecretType_array_init_wrapper,
262		wst_BinarySecretType_array_destroy_wrapper,
263		wst_BinarySecretType_array_copy_wrapper,
264		wst_BinarySecretType_array_init_contents_wrapper,
265		wst_BinarySecretType_array_destroy_contents_wrapper,
266		wst_BinarySecretType_array_copy_contents_wrapper,
267		sizeof(wst_BinarySecretType),
268		wst_BinarySecretType_array_push_wrapper,
269		NULL,
270		NULL
271		};
272
273		struct globus_xsd_type_info_s wst_BinarySecretType_info =
274		{
275		&wst_BinarySecretType_qname,
276		wst_BinarySecretType_serialize_wrapper,
277		wst_BinarySecretType_deserialize_pointer_wrapper,
278		wst_BinarySecretType_init_wrapper,
279		wst_BinarySecretType_destroy_wrapper,
280		wst_BinarySecretType_copy_wrapper,
281		wst_BinarySecretType_init_contents_wrapper,
282		wst_BinarySecretType_destroy_contents_wrapper,
283		wst_BinarySecretType_copy_contents_wrapper,
284		sizeof(wst_BinarySecretType),
285		NULL,
286		&wst_BinarySecretType_contents_info,
287		&wst_BinarySecretType_array_info
288		};
289
290		globus_result_t
291		wst_BinarySecretType_init_contents(
292		wst_BinarySecretType * instance)
293	0	{
294	0	globus_result_t                     result = GLOBUS_SUCCESS;
295	0	GlobusFuncName(wst_BinarySecretType_init_contents);
296	0	GlobusSoapMessageDebugEnter();
297
298	0	memset(instance, 0, sizeof(wst_BinarySecretType));
299
300	0	GlobusSoapMessageDebugExit();
301	0	return result;
302		}
303
304		globus_result_t
305		wst_BinarySecretType_init(
306		wst_BinarySecretType ** object)
307	0	{
308	0	wst_BinarySecretType * instance;
309	0	globus_result_t                     result = GLOBUS_SUCCESS;
310	0	GlobusFuncName(wst_BinarySecretType_init);
311	0	GlobusSoapMessageDebugEnter();
312
313	0	instance = globus_malloc(sizeof(wst_BinarySecretType));
314	0	if(!instance)
315		{
316	0	result = GlobusSoapMessageErrorOutOfMemory;
317	0	goto exit;
318		}
319
320	0	memset(instance, 0, sizeof(wst_BinarySecretType));
321
322	0	*object = instance;
323
324		exit:
325	0	GlobusSoapMessageDebugExit();
326	0	return result;
327		}
328
329		void
330		wst_BinarySecretType_destroy(
331		wst_BinarySecretType * instance)
332	0	{
333	0	GlobusFuncName(wst_BinarySecretType_destroy);
334	0	GlobusSoapMessageDebugEnter();
335
336	0	if(!instance)
337		{
338	0	goto exit;
339		}
340
341	0	wst_BinarySecretType_destroy_contents(instance);
342	0	globus_free(instance);
343
344		exit:
345
346	0	GlobusSoapMessageDebugExit();
347		}
348
349		void
350		wst_BinarySecretType_destroy_contents(
351		wst_BinarySecretType * instance)
352	0	{
353	0	GlobusFuncName(wst_BinarySecretType_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	if(instance)
357		{
358
359
360	0	xsd_base64Binary_destroy_contents(
361		&instance->base_value);
362
363	0	xsd_anyAttributes_destroy(instance->anyAttributes);
364	0	instance->anyAttributes = NULL;
365
366	0	if(instance->_Type)
367		{
368	0	wst_BinarySecretTypeOpenEnum_destroy(
369		instance->_Type);
370	0	instance->_Type = NULL;
371		}
372
373		}
374
375	0	GlobusSoapMessageDebugExit();
376		}
377
378		globus_result_t
379		wst_BinarySecretType_copy(
380		wst_BinarySecretType ** dest_obj,
381		const wst_BinarySecretType * src_obj)
382	0	{
383	0	globus_result_t                     result = GLOBUS_SUCCESS;
384	0	wst_BinarySecretType * instance;
385	0	GlobusFuncName(wst_BinarySecretType_copy);
386
387	0	GlobusSoapMessageDebugEnter();
388
389	0	instance = malloc(sizeof(wst_BinarySecretType));
390	0	if (instance == NULL)
391		{
392	0	GlobusSoapMessageDebugExit();
393	0	return GlobusSoapMessageErrorOutOfMemory;
394		}
395
396	0	result = wst_BinarySecretType_copy_contents(instance, src_obj);
397	0	if(result != GLOBUS_SUCCESS)
398		{
399	0	globus_free(instance);
400	0	GlobusSoapMessageDebugExit();
401	0	return GlobusSoapMessageErrorOutOfMemory;
402		}
403
404	0	*dest_obj = instance;
405	0	GlobusSoapMessageDebugExit();
406	0	return result;
407		}
408
409		globus_result_t
410		wst_BinarySecretType_copy_contents(
411		wst_BinarySecretType * instance,
412		const wst_BinarySecretType * src_obj)
413	0	{
414	0	globus_result_t                     result = GLOBUS_SUCCESS;
415	0	GlobusFuncName(wst_BinarySecretType_copy_contents);
416
417	0	GlobusSoapMessageDebugEnter();
418
419
420	0	if(src_obj->anyAttributes)
421		{
422	0	result = xsd_anyAttributes_copy(&instance->anyAttributes,
423		src_obj->anyAttributes);
424	0	if(result != GLOBUS_SUCCESS)
425		{
426	0	result = GlobusSoapMessageErrorCopyAnyAttrsFailed(
427		result, NULL);
428	0	goto xsd_anyAttributes_after_destroy;
429		}
430		}
431		else
432		{
433	0	instance->anyAttributes = NULL;
434		}
435
436	0	if(src_obj->_Type)
437		{
438	0	result = wst_BinarySecretTypeOpenEnum_copy(
439		&instance->_Type,
440		src_obj->_Type);
441	0	if(result != GLOBUS_SUCCESS)
442		{
443	0	result = GlobusSoapMessageErrorCopyFailed(
444		result, NULL, &wst_BinarySecretTypeOpenEnum_qname);
445	0	goto _Type_destroy;
446		}
447		}
448		else
449		{
450	0	instance->_Type = NULL;
451		}
452
453	0	result = xsd_base64Binary_copy_contents(
454		&instance->base_value,
455		&src_obj->base_value);
456	0	if(result != GLOBUS_SUCCESS)
457		{
458	0	result = GlobusSoapMessageErrorCopyFailed(
459		result, NULL,  &xsd_base64Binary_qname);
460	0	goto base_value_destroy;
461		}
462
463	0	goto exit;
464
465		fail_deserialize:
466
467		xsd_anyAttributes_destroy:
468	0	xsd_anyAttributes_destroy(instance->anyAttributes);
469	0	instance->anyAttributes = NULL;
470		xsd_anyAttributes_after_destroy:
471	0	xsd_base64Binary_destroy_contents(
472		&instance->base_value);
473
474		base_value_destroy:
475
476		_Type_destroy:
477
478	0	if(instance->_Type)
479		{
480	0	wst_BinarySecretTypeOpenEnum_destroy(
481		instance->_Type);
482	0	instance->_Type = NULL;
483		}
484
485
486		exit:
487
488	0	GlobusSoapMessageDebugExit();
489	0	return result;
490		}
491
492
493
494		globus_result_t
495		wst_BinarySecretType_serialize_contents(
496		xsd_QName *                         element_qname, /* ignored */
497		wst_BinarySecretType * inst,
498		globus_soap_message_handle_t        message_handle,
499		globus_xsd_element_options_t        options)
500	0	{
501	0	globus_result_t                     result = GLOBUS_SUCCESS;
502	0	GlobusFuncName(wst_BinarySecretType_serialize_contents);
503	0	GlobusSoapMessageDebugEnter();
504
505	0	result = wst_BinarySecretType_serialize(
506		NULL,
507		inst,
508		message_handle,
509		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
510	0	if(result != GLOBUS_SUCCESS)
511		{
512	0	result = GlobusSoapMessageErrorSerializeFailed(
513		result, NULL, element_qname);
514		goto exit;
515		}
516
517		exit:
518
519	0	GlobusSoapMessageDebugExit();
520	0	return result;
521		}
522
523
524
525		globus_result_t
526		wst_BinarySecretType_serialize(
527		xsd_QName *                         element_qname,
528		wst_BinarySecretType * instance,
529		globus_soap_message_handle_t        message_handle,
530		globus_xsd_element_options_t        options)
531	0	{
532	0	globus_result_t                     result = GLOBUS_SUCCESS;
533	0	xsd_QName                           subelement;
534	0	globus_list_t *                     any_attr_keys = NULL;
535	0	globus_list_t *                     any_attr_keys_iterator = NULL;
536	0	xsd_QName *                         type_attr = NULL;
537	0	char *                              prefix = NULL;
538	0	int                                 prefix_created;
539	0	int                                 define_prefix = 0;
540	0	int                                 save_options = options;
541
542	0	GlobusFuncName(wst_BinarySecretType_serialize);
543	0	GlobusSoapMessageDebugEnter();
544
545
546	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
547		{
548		/* serialize wst_BinarySecretType element */
549
550	0	result = globus_soap_message_invoke_ns_callouts(
551		message_handle,
552		element_qname,
553		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_SET,
554		&options);
555	0	if(result != GLOBUS_SUCCESS)
556		{
557	0	result = GlobusSoapMessageErrorSerializeFailed(
558		result, NULL, element_qname);
559	0	goto exit;
560		}
561
562	0	result = globus_soap_message_element_ns_set(
563		message_handle,
564		element_qname->Namespace,
565		&options);
566	0	if(result != GLOBUS_SUCCESS)
567		{
568	0	result = GlobusSoapMessageErrorSerializeFailed(
569		result, NULL, element_qname);
570	0	goto exit;
571		}
572
573	0	result = xsd_anyAttributes_namespace_set(
574		message_handle, instance->anyAttributes, &options);
575	0	if(result != GLOBUS_SUCCESS)
576		{
577	0	result = GlobusSoapMessageErrorSerializeAnyAttrsFailed(
578		result, "Failed to set namespace");
579	0	goto exit;
580		}
581
582	0	if(instance->_Type)
583		{
584
585	0	result = globus_soap_message_attribute_ns_set(
586		message_handle,
587		NULL,
588		&options);
589
590	0	if(result != GLOBUS_SUCCESS)
591		{
592	0	xsd_QName               error_qname;
593	0	error_qname.local = prefix;
594	0	error_qname.Namespace = "";
595	0	result = GlobusSoapMessageErrorSerializeFailed(result,
596		NULL,
597		&error_qname);
598	0	goto exit;
599		}
600
601
602		}
603
604	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
605		!globus_soap_message_serialize_is_c14n_subset(message_handle))
606		{
607	0	result = globus_soap_message_attribute_ns_set(
608		message_handle,
609		"http://www.w3.org/2001/XMLSchema-instance",
610		&options);
611	0	if(result != GLOBUS_SUCCESS)
612		{
613	0	result = GlobusSoapMessageErrorSerializeFailed(
614		result, NULL, element_qname);
615	0	goto exit;
616		}
617
618	0	result = globus_soap_message_attribute_ns_set(
619		message_handle,
620		wst_BinarySecretType_qname.Namespace,
621		&options);
622	0	if(result != GLOBUS_SUCCESS)
623		{
624	0	result = GlobusSoapMessageErrorSerializeFailed(
625		result, NULL, element_qname);
626	0	goto exit;
627		}
628		}
629
630	0	result = globus_soap_message_invoke_callouts(
631		message_handle,
632		element_qname,
633		GLOBUS_SOAP_MESSAGE_CALLOUT_BEGIN);
634	0	if(result != GLOBUS_SUCCESS)
635		{
636	0	result = GlobusSoapMessageErrorSerializeFailed(
637		result, NULL, element_qname);
638	0	goto exit;
639		}
640
641	0	result = globus_soap_message_serialize_element(
642		message_handle,
643		element_qname,
644		options,
645		&wst_BinarySecretType_qname);
646	0	if(result != GLOBUS_SUCCESS)
647		{
648	0	result = GlobusSoapMessageErrorSerializeFailed(
649		result, NULL, element_qname);
650	0	goto exit;
651		}
652
653	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
654		!globus_soap_message_serialize_is_c14n_subset(message_handle))
655		{
656	0	xsd_QName_init(&type_attr);
657
658	0	type_attr->local = globus_libc_strdup("type");
659	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
660		}
661
662		/* serialize namespaces */
663
664	0	result = globus_soap_message_invoke_ns_callouts(
665		message_handle,
666		element_qname,
667		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_ADD,
668		&options);
669	0	if(result != GLOBUS_SUCCESS)
670		{
671	0	result = GlobusSoapMessageErrorSerializeFailed(
672		result, NULL, element_qname);
673	0	goto exit;
674		}
675
676	0	result = globus_soap_message_element_ns_add(
677		message_handle,
678		element_qname->Namespace,
679		&options);
680	0	if(result != GLOBUS_SUCCESS)
681		{
682	0	result = GlobusSoapMessageErrorSerializeFailed(
683		result, NULL, element_qname);
684	0	goto exit;
685		}
686
687	0	result = xsd_anyAttributes_namespace_add(
688		message_handle, instance->anyAttributes, &options);
689	0	if(result != GLOBUS_SUCCESS)
690		{
691	0	result = GlobusSoapMessageErrorSerializeAnyAttrsFailed(
692		result, "Failed to add namespace");
693	0	goto exit;
694		}
695
696	0	if(instance->_Type)
697		{
698
699	0	result = globus_soap_message_attribute_ns_add(
700		message_handle,
701		NULL,
702		&options);
703
704	0	if(result != GLOBUS_SUCCESS)
705		{
706	0	xsd_QName               error_qname;
707	0	error_qname.local = prefix;
708	0	error_qname.Namespace = "";
709	0	result = GlobusSoapMessageErrorSerializeFailed(result,
710		NULL,
711		&error_qname);
712	0	goto exit;
713		}
714
715
716		}
717
718	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
719		!globus_soap_message_serialize_is_c14n_subset(message_handle))
720		{
721	0	result = globus_soap_message_attribute_ns_add(
722		message_handle,
723		"http://www.w3.org/2001/XMLSchema-instance",
724		&options);
725	0	if(result != GLOBUS_SUCCESS)
726		{
727	0	result = GlobusSoapMessageErrorSerializeFailed(
728		result, NULL, element_qname);
729	0	goto exit;
730		}
731
732	0	result = globus_soap_message_attribute_ns_add(
733		message_handle,
734		wst_BinarySecretType_qname.Namespace,
735		&options);
736	0	if(result != GLOBUS_SUCCESS)
737		{
738	0	result = GlobusSoapMessageErrorSerializeFailed(
739		result, NULL, element_qname);
740	0	goto exit;
741		}
742		}
743
744		/* serialize attributes */
745
746	0	if(instance->anyAttributes)
747		{
748	0	any_attr_keys = xsd_anyAttributes_lex_sort(
749		instance->anyAttributes);
750	0	any_attr_keys_iterator = any_attr_keys;
751		}
752
753	0	subelement.Namespace = "";
754	0	subelement.local = "Type";
755
756	0	if(any_attr_keys_iterator)
757		{
758	0	result = xsd_anyAttributes_serialize_lex_before(
759		message_handle,
760		&any_attr_keys_iterator,
761		instance->anyAttributes,
762		&subelement);
763	0	if(result != GLOBUS_SUCCESS)
764		{
765	0	result = GlobusSoapMessageErrorSerializeFailed(result,
766		NULL,
767		element_qname);
768	0	goto exit;
769		}
770		}
771
772	0	if(instance->_Type)
773		{
774
775	0	result = wst_BinarySecretTypeOpenEnum_serialize_attribute(
776		&subelement,
777		instance->_Type,
778		message_handle,
779		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
780	0	if(result != GLOBUS_SUCCESS)
781		{
782	0	result = GlobusSoapMessageErrorSerializeFailed(result,
783		NULL,
784		element_qname);
785	0	goto exit;
786		}
787
788		}
789
790	0	if(any_attr_keys_iterator)
791		{
792	0	result = xsd_anyAttributes_serialize_lex_before(
793		message_handle,
794		&any_attr_keys_iterator,
795		instance->anyAttributes,
796		&subelement);
797	0	if(result != GLOBUS_SUCCESS)
798		{
799	0	result = GlobusSoapMessageErrorSerializeFailed(result,
800		NULL,
801		element_qname);
802	0	goto exit;
803		}
804		}
805
806	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
807		!globus_soap_message_serialize_is_c14n_subset(message_handle))
808		{
809	0	result = globus_soap_message_serialize_QName_attribute(
810		message_handle,
811		type_attr,
812		&wst_BinarySecretType_qname);
813	0	if(result != GLOBUS_SUCCESS)
814		{
815	0	result = GlobusSoapMessageErrorSerializeFailed(
816		result, NULL, element_qname);
817	0	goto exit;
818		}
819		}
820
821
822	0	result = globus_soap_message_invoke_callouts(
823		message_handle,
824		element_qname,
825		GLOBUS_SOAP_MESSAGE_CALLOUT_ATTR);
826	0	if(result != GLOBUS_SUCCESS)
827		{
828	0	result = GlobusSoapMessageErrorSerializeFailed(
829		result, NULL, element_qname);
830	0	goto exit;
831		}
832		}
833
834	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
835		{
836	0	result = globus_soap_message_serialize_element_begin_close(
837		message_handle);
838	0	if(result != GLOBUS_SUCCESS)
839		{
840	0	result = GlobusSoapMessageErrorSerializeFailed(
841		result, NULL, element_qname);
842	0	goto exit;
843		}
844		}
845	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
846
847		/* serialize contents of type */
848
849	0	subelement.local = "base_value";
850	0	subelement.Namespace = NULL;
851
852	0	result = xsd_base64Binary_serialize(
853		&subelement,
854		&instance->base_value,
855		message_handle,
856		GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
857	0	if(result != GLOBUS_SUCCESS)
858		{
859	0	result = GlobusSoapMessageErrorSerializeFailed(
860		result, NULL,  &xsd_base64Binary_qname);
861	0	goto exit;
862		}
863
864	0	options = save_options;
865
866	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
867		{
868		/* add end element */
869	0	result = globus_soap_message_serialize_element_end(
870		message_handle,
871		element_qname,
872		options,
873		&wst_BinarySecretType_qname);
874	0	if(result != GLOBUS_SUCCESS)
875		{
876	0	result = GlobusSoapMessageErrorSerializeFailed(
877		result, NULL, element_qname);
878	0	goto exit;
879		}
880
881	0	globus_soap_message_element_ns_remove(
882		message_handle,
883		element_qname->Namespace,
884		&options);
885
886		/* remove namespace/prefix mappings for these types */
887
888	0	result = xsd_anyAttributes_namespace_remove(
889		message_handle, instance->anyAttributes, &options);
890	0	if(result != GLOBUS_SUCCESS)
891		{
892	0	result = GlobusSoapMessageErrorSerializeAnyAttrsFailed(
893		result, "Failed to remove namespace");
894	0	goto exit;
895		}
896
897	0	if(instance->_Type)
898		{
899
900	0	globus_soap_message_attribute_ns_remove(
901		message_handle,
902		NULL,
903		&options);
904
905		}
906
907	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
908		!globus_soap_message_serialize_is_c14n_subset(message_handle))
909		{
910	0	globus_soap_message_attribute_ns_remove(
911		message_handle,
912		"http://www.w3.org/2001/XMLSchema-instance",
913		&options);
914
915	0	globus_soap_message_attribute_ns_remove(
916		message_handle,
917		wst_BinarySecretType_qname.Namespace,
918		&options);
919		}
920
921	0	result = globus_soap_message_invoke_ns_callouts(
922		message_handle,
923		element_qname,
924		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_REMOVE,
925		&options);
926	0	if(result != GLOBUS_SUCCESS)
927		{
928	0	result  = GlobusSoapMessageErrorSerializeFailed(
929		result, NULL, element_qname);
930	0	goto exit;
931		}
932
933	0	result = globus_soap_message_invoke_callouts(
934		message_handle,
935		element_qname,
936		GLOBUS_SOAP_MESSAGE_CALLOUT_END);
937	0	if(result != GLOBUS_SUCCESS)
938		{
939	0	result = GlobusSoapMessageErrorSerializeFailed(
940		result, NULL, element_qname);
941		goto exit;
942		}
943		}
944
945		exit:
946	0	if (type_attr)
947		{
948	0	xsd_QName_destroy(type_attr);
949		}
950
951	0	if(any_attr_keys)
952		{
953	0	globus_list_free(any_attr_keys);
954		}
955
956	0	GlobusSoapMessageDebugExit();
957	0	return result;
958		}
959
960
961
962		globus_result_t
963		wst_BinarySecretType_deserialize_contents(
964		xsd_QName *                         element_qname, /* ignored */
965		wst_BinarySecretType * inst,
966		globus_soap_message_handle_t        message_handle,
967		globus_xsd_element_options_t        options)
968	0	{
969	0	globus_result_t                     result = GLOBUS_SUCCESS;
970	0	GlobusFuncName(wst_BinarySecretType_deserialize_contents);
971	0	GlobusSoapMessageDebugEnter();
972
973	0	result = wst_BinarySecretType_deserialize(
974		NULL,
975		inst,
976		message_handle,
977		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
978	0	if(result != GLOBUS_SUCCESS)
979		{
980	0	result = GlobusSoapMessageErrorDeserializeFailed(
981		result, element_qname);
982		goto exit;
983		}
984
985		exit:
986
987	0	GlobusSoapMessageDebugExit();
988	0	return result;
989		}
990
991
992
993		globus_result_t
994		wst_BinarySecretType_deserialize(
995		xsd_QName *                         element_qname,
996		wst_BinarySecretType * instance,
997		globus_soap_message_handle_t        message_handle,
998		globus_xsd_element_options_t        options)
999	0	{
1000	0	globus_result_t                     result = GLOBUS_SUCCESS;
1001	0	xsd_QName                           subelement;
1002	0	GlobusFuncName(wst_BinarySecretType_deserialize);
1003	0	GlobusSoapMessageDebugEnter();
1004
1005
1006	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1007		{
1008	0	result = globus_soap_message_deserialize_element(
1009		message_handle, element_qname);
1010	0	if(result != GLOBUS_SUCCESS)
1011		{
1012	0	result = GlobusSoapMessageErrorDeserializeFailed(
1013		result, element_qname);
1014	0	goto exit;
1015		}
1016
1017	0	result = xsd_anyAttributes_init(&instance->anyAttributes);
1018	0	if(result != GLOBUS_SUCCESS)
1019		{
1020	0	result = GlobusSoapMessageErrorDeserializeFailed(
1021		result, element_qname);
1022	0	goto xsd_anyAttributes_after_destroy;
1023		}
1024
1025	0	result = xsd_anyAttributes_deserialize(
1026		message_handle,
1027		instance->anyAttributes);
1028	0	if(result != GLOBUS_SUCCESS)
1029		{
1030	0	result = GlobusSoapMessageErrorDeserializeFailed(
1031		result, element_qname);
1032	0	goto xsd_anyAttributes_destroy;
1033		}
1034
1035	0	subelement.Namespace = "";
1036	0	subelement.local = "Type";
1037
1038	0	result = wst_BinarySecretTypeOpenEnum_deserialize_attribute_pointer(
1039		&subelement,
1040		&instance->_Type,
1041		message_handle,
1042		0);
1043	0	if(result != GLOBUS_SUCCESS)
1044		{
1045	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1046	0	goto _Type_destroy;
1047		}
1048
1049
1050
1051	0	result = globus_soap_message_deserialize_element_begin_close(
1052		message_handle);
1053	0	if(result != GLOBUS_SUCCESS)
1054		{
1055	0	result = GlobusSoapMessageErrorDeserializeFailed(
1056		result, element_qname);
1057	0	goto fail_deserialize;
1058		}
1059		}
1060
1061	0	subelement.local = "base_value";
1062	0	subelement.Namespace = NULL;
1063
1064	0	result = xsd_base64Binary_deserialize(
1065		&subelement,
1066		&instance->base_value,
1067		message_handle,
1068		GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1069	0	if(result != GLOBUS_SUCCESS)
1070		{
1071	0	result = GlobusSoapMessageErrorDeserializeFailed(
1072		result,
1073		&xsd_base64Binary_qname);
1074	0	goto base_value_destroy;
1075		}
1076
1077	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1078		{
1079	0	result = globus_soap_message_deserialize_element_end(
1080		message_handle,
1081		element_qname);
1082	0	if(result != GLOBUS_SUCCESS)
1083		{
1084	0	result = GlobusSoapMessageErrorDeserializeFailed(
1085		result, element_qname);
1086		goto fail_deserialize;
1087		}
1088		}
1089
1090	0	goto exit;
1091
1092		fail_deserialize:
1093
1094		xsd_anyAttributes_destroy:
1095	0	xsd_anyAttributes_destroy(instance->anyAttributes);
1096	0	instance->anyAttributes = NULL;
1097		xsd_anyAttributes_after_destroy:
1098	0	xsd_base64Binary_destroy_contents(
1099		&instance->base_value);
1100
1101		base_value_destroy:
1102
1103		_Type_destroy:
1104
1105	0	if(instance->_Type)
1106		{
1107	0	wst_BinarySecretTypeOpenEnum_destroy(
1108		instance->_Type);
1109	0	instance->_Type = NULL;
1110		}
1111
1112
1113		exit:
1114
1115	0	GlobusSoapMessageDebugExit();
1116	0	return result;
1117		}
1118
1119
1120
1121		globus_result_t
1122		wst_BinarySecretType_deserialize_pointer(
1123		xsd_QName *                         element_qname,
1124		wst_BinarySecretType ** ip,
1125		globus_soap_message_handle_t        message_handle,
1126		globus_xsd_element_options_t        options)
1127	0	{
1128	0	wst_BinarySecretType * instance = NULL;
1129	0	globus_result_t                     result = GLOBUS_SUCCESS;
1130	0	xsd_QName                           subelement;
1131	0	int                                 found_attrs = 0;
1132	0	int                                 empty_element = 0;
1133	0	GlobusFuncName(wst_BinarySecretType_deserialize_pointer);
1134	0	GlobusSoapMessageDebugEnter();
1135
1136	0	*ip = NULL;
1137
1138	0	result = globus_soap_message_deserialize_element(
1139		message_handle, element_qname);
1140	0	if(result != GLOBUS_SUCCESS &&
1141		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1142		GlobusSoapMessageStatusFailedElementCheck(result) ||
1143		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1144		{
1145	0	*ip = NULL;
1146	0	result = GLOBUS_SUCCESS;
1147	0	goto exit;
1148		}
1149
1150	0	if(result != GLOBUS_SUCCESS)
1151		{
1152	0	result = GlobusSoapMessageErrorDeserializeFailed(
1153		result, element_qname);
1154	0	goto exit;
1155		}
1156
1157	0	if(globus_soap_message_deserialize_element_is_empty(
1158		message_handle))
1159		{
1160	0	empty_element = 1;
1161		}
1162
1163
1164
1165	0	result = wst_BinarySecretType_init(&instance);
1166	0	if(result != GLOBUS_SUCCESS)
1167		{
1168	0	result = GlobusSoapMessageErrorDeserializeFailed(
1169		result, element_qname);
1170	0	goto exit;
1171		}
1172
1173
1174	0	result = xsd_anyAttributes_init(&instance->anyAttributes);
1175	0	if(result != GLOBUS_SUCCESS)
1176		{
1177	0	result = GlobusSoapMessageErrorDeserializeFailed(
1178		result, element_qname);
1179	0	goto xsd_anyAttributes_after_destroy;
1180		}
1181
1182	0	result = xsd_anyAttributes_deserialize(
1183		message_handle,
1184		instance->anyAttributes);
1185	0	if(result != GLOBUS_SUCCESS)
1186		{
1187	0	result = GlobusSoapMessageErrorDeserializeFailed(
1188		result, element_qname);
1189	0	goto xsd_anyAttributes_destroy;
1190		}
1191
1192	0	if(instance->anyAttributes &&
1193		xsd_anyAttributes_size(instance->anyAttributes) > 0)
1194		{
1195	0	found_attrs++;
1196		}
1197
1198	0	subelement.Namespace = "";
1199	0	subelement.local = "Type";
1200
1201	0	result = wst_BinarySecretTypeOpenEnum_deserialize_attribute_pointer(
1202		&subelement,
1203		&instance->_Type,
1204		message_handle,
1205		0);
1206	0	if(result != GLOBUS_SUCCESS)
1207		{
1208	0	result = GlobusSoapMessageErrorDeserializeFailed(result, &subelement);
1209	0	goto _Type_destroy;
1210		}
1211
1212
1213	0	if(instance->_Type)
1214		{
1215	0	found_attrs++;
1216		}
1217
1218
1219	0	if(empty_element)
1220		{
1221	0	result = globus_soap_message_deserialize_element_end(
1222		message_handle,
1223		element_qname);
1224	0	if(result != GLOBUS_SUCCESS)
1225		{
1226	0	result = GlobusSoapMessageErrorDeserializeFailed(
1227		result, element_qname);
1228	0	goto fail_deserialize;
1229		}
1230
1231	0	*ip = instance;
1232	0	goto exit;
1233		}
1234
1235	0	result = globus_soap_message_deserialize_element_begin_close(
1236		message_handle);
1237	0	if(result != GLOBUS_SUCCESS)
1238		{
1239	0	result = GlobusSoapMessageErrorDeserializeFailed(
1240		result, element_qname);
1241	0	goto exit;
1242		}
1243
1244
1245	0	subelement.local = "base_value";
1246	0	subelement.Namespace = NULL;
1247
1248	0	result = xsd_base64Binary_deserialize(
1249		&subelement,
1250		&instance->base_value,
1251		message_handle,
1252		GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
1253	0	if(result != GLOBUS_SUCCESS)
1254		{
1255	0	result = GlobusSoapMessageErrorDeserializeFailed(
1256		result,
1257		&xsd_base64Binary_qname);
1258	0	goto base_value_destroy;
1259		}
1260
1261
1262	0	result = globus_soap_message_deserialize_element_end(
1263		message_handle,
1264		element_qname);
1265	0	if(result != GLOBUS_SUCCESS)
1266		{
1267	0	result = GlobusSoapMessageErrorDeserializeFailed(
1268		result, element_qname);
1269	0	goto fail_deserialize;
1270		}
1271
1272	0	*ip = instance;
1273
1274	0	goto exit;
1275
1276		fail_deserialize:
1277
1278		xsd_anyAttributes_destroy:
1279	0	xsd_anyAttributes_destroy(instance->anyAttributes);
1280	0	instance->anyAttributes = NULL;
1281		xsd_anyAttributes_after_destroy:
1282	0	xsd_base64Binary_destroy_contents(
1283		&instance->base_value);
1284
1285		base_value_destroy:
1286
1287		_Type_destroy:
1288
1289	0	if(instance->_Type)
1290		{
1291	0	wst_BinarySecretTypeOpenEnum_destroy(
1292		instance->_Type);
1293	0	instance->_Type = NULL;
1294		}
1295
1296		exit:
1297
1298	0	GlobusSoapMessageDebugExit();
1299	0	return result;
1300		}
1301
1302
1303		globus_result_t
1304		wst_BinarySecretType_array_init_contents(
1305		wst_BinarySecretType_array * array)
1306	0	{
1307	0	GlobusFuncName(wst_BinarySecretType_array_init_contents);
1308	0	GlobusSoapMessageDebugEnter();
1309
1310	0	memset(array, 0, sizeof(wst_BinarySecretType_array));
1311
1312	0	GlobusSoapMessageDebugExit();
1313	0	return GLOBUS_SUCCESS;
1314		}
1315
1316		globus_result_t
1317		wst_BinarySecretType_array_init(
1318		wst_BinarySecretType_array ** arr)
1319	0	{
1320	0	wst_BinarySecretType_array * array;
1321	0	globus_result_t                     result;
1322	0	GlobusFuncName(wst_BinarySecretType_array_init);
1323	0	GlobusSoapMessageDebugEnter();
1324
1325	0	array = (wst_BinarySecretType_array *)
1326		globus_malloc(sizeof(wst_BinarySecretType_array));
1327	0	if(!array)
1328		{
1329	0	result = GlobusSoapMessageErrorOutOfMemory;
1330	0	goto exit;
1331		}
1332
1333	0	result = wst_BinarySecretType_array_init_contents(array);
1334	0	if(result != GLOBUS_SUCCESS)
1335		{
1336	0	globus_free(array);
1337	0	array = NULL;
1338
1339		}
1340
1341	0	*arr = array;
1342
1343		exit:
1344	0	GlobusSoapMessageDebugExit();
1345	0	return result;
1346		}
1347
1348		void
1349		wst_BinarySecretType_array_destroy_contents(
1350		wst_BinarySecretType_array * array)
1351	0	{
1352	0	int                                 i = 0;
1353	0	GlobusFuncName(wst_BinarySecretType_array_destroy_contents);
1354	0	GlobusSoapMessageDebugEnter();
1355
1356	0	for(; i < array->length; ++i)
1357		{
1358	0	wst_BinarySecretType_destroy_contents(&array->elements[i]);
1359		}
1360
1361	0	if(array->elements)
1362		{
1363	0	globus_free(array->elements);
1364	0	array->elements = NULL;
1365		}
1366	0	array->length = 0;
1367
1368	0	GlobusSoapMessageDebugExit();
1369		}
1370
1371		void
1372		wst_BinarySecretType_array_destroy(
1373		wst_BinarySecretType_array * array)
1374	0	{
1375	0	GlobusFuncName(wst_BinarySecretType_array_destroy);
1376	0	GlobusSoapMessageDebugEnter();
1377
1378	0	wst_BinarySecretType_array_destroy_contents(array);
1379	0	globus_free(array);
1380
1381	0	GlobusSoapMessageDebugExit();
1382		}
1383
1384		globus_result_t
1385		wst_BinarySecretType_array_copy(
1386		wst_BinarySecretType_array ** dest_arr,
1387		const wst_BinarySecretType_array * src_arr)
1388	0	{
1389	0	wst_BinarySecretType_array * array;
1390	0	globus_result_t                     result;
1391	0	GlobusFuncName(wst_BinarySecretType_array_copy);
1392	0	GlobusSoapMessageDebugEnter();
1393
1394	0	array = (wst_BinarySecretType_array *) globus_malloc(
1395		sizeof(wst_BinarySecretType_array));
1396	0	if(!array)
1397		{
1398	0	result = GlobusSoapMessageErrorOutOfMemory;
1399	0	GlobusSoapMessageDebugExit();
1400	0	return result;
1401		}
1402
1403	0	result = wst_BinarySecretType_array_copy_contents(array, src_arr);
1404	0	if(result != GLOBUS_SUCCESS)
1405		{
1406	0	globus_free(array);
1407	0	GlobusSoapMessageDebugExit();
1408	0	return result;
1409		}
1410
1411	0	*dest_arr = array;
1412
1413	0	GlobusSoapMessageDebugExit();
1414	0	return GLOBUS_SUCCESS;
1415		}
1416
1417		globus_result_t
1418		wst_BinarySecretType_array_copy_contents(
1419		wst_BinarySecretType_array * dest_arr,
1420		const wst_BinarySecretType_array * src_arr)
1421	0	{
1422	0	int                                 i;
1423	0	globus_result_t                     result = GLOBUS_SUCCESS;
1424	0	GlobusFuncName(wst_BinarySecretType_array_copy_contents);
1425	0	GlobusSoapMessageDebugEnter();
1426
1427	0	dest_arr->length = src_arr->length;
1428	0	if(dest_arr->length > 0)
1429		{
1430	0	dest_arr->elements = (wst_BinarySecretType *) malloc(
1431		sizeof(wst_BinarySecretType) * dest_arr->length);
1432	0	if(!dest_arr->elements)
1433		{
1434	0	result = GlobusSoapMessageErrorOutOfMemory;
1435	0	GlobusSoapMessageDebugExit();
1436	0	return result;
1437		}
1438		}
1439		else
1440		{
1441	0	dest_arr->elements = NULL;
1442		}
1443
1444	0	for(i = 0; i < dest_arr->length; i++)
1445		{
1446	0	result = wst_BinarySecretType_copy_contents(
1447		&dest_arr->elements[i], &src_arr->elements[i]);
1448	0	if(result != GLOBUS_SUCCESS)
1449		{
1450	0	while(i--)
1451		{
1452	0	wst_BinarySecretType_destroy_contents(&dest_arr->elements[i]);
1453		}
1454
1455	0	globus_free(dest_arr->elements);
1456	0	dest_arr->elements = NULL;
1457	0	dest_arr->length = 0;
1458	0	break;
1459		}
1460		}
1461
1462	0	GlobusSoapMessageDebugExit();
1463	0	return result;
1464		}
1465
1466		wst_BinarySecretType *
1467		wst_BinarySecretType_array_push(
1468		wst_BinarySecretType_array * array)
1469	0	{
1470	0	GlobusFuncName(wst_BinarySecretType_array_push);
1471	0	GlobusSoapMessageDebugEnter();
1472
1473	0	array->elements = realloc(array->elements,
1474		sizeof(wst_BinarySecretType) *
1475		(array->length + 1));
1476	0	memset(&array->elements[array->length], 0, sizeof(wst_BinarySecretType));
1477	0	array->length++;
1478
1479	0	GlobusSoapMessageDebugExit();
1480	0	return (&array->elements[array->length - 1]);
1481		}
1482
1483		void *
1484		wst_BinarySecretType_array_push_wrapper(
1485		void * array)
1486	0	{
1487	0	return (void *) wst_BinarySecretType_array_push((wst_BinarySecretType_array *) array);
1488		}
1489
1490		globus_result_t
1491		wst_BinarySecretType_array_serialize(
1492		xsd_QName *                         element_qname,
1493		wst_BinarySecretType_array * array,
1494		globus_soap_message_handle_t        message,
1495		globus_xsd_element_options_t        options)
1496	0	{
1497	0	globus_result_t                     result = GLOBUS_SUCCESS;
1498	0	int                                 i = 0;
1499	0	GlobusFuncName(wst_BinarySecretType_array_serialize);
1500	0	GlobusSoapMessageDebugEnter();
1501
1502	0	for(; i < array->length; ++i)
1503		{
1504	0	result = wst_BinarySecretType_serialize(
1505		element_qname,
1506		&array->elements[i],
1507		message,
1508		options);
1509	0	if(result != GLOBUS_SUCCESS)
1510		{
1511	0	goto exit;
1512		}
1513		}
1514
1515		exit:
1516
1517	0	GlobusSoapMessageDebugExit();
1518	0	return result;
1519		}
1520
1521		globus_result_t
1522		wst_BinarySecretType_array_deserialize(
1523		xsd_QName *                         element_qname,
1524		wst_BinarySecretType_array * array,
1525		globus_soap_message_handle_t        message,
1526		globus_xsd_element_options_t        options)
1527	0	{
1528	0	globus_result_t                     result = GLOBUS_SUCCESS;
1529	0	int                                 i = 0;
1530	0	int                                 pre_length;
1531	0	GlobusFuncName(wst_BinarySecretType_array_deserialize);
1532	0	GlobusSoapMessageDebugEnter();
1533
1534	0	pre_length = array->length;
1535
1536	0	for(i = 0; i < pre_length; ++i)
1537		{
1538	0	result = wst_BinarySecretType_deserialize(
1539		element_qname,
1540		&array->elements[i],
1541		message,
1542		options);
1543	0	if(result != GLOBUS_SUCCESS)
1544		{
1545	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1546		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1547		GlobusSoapMessageStatusFailedWithTextCheck(result))
1548		{
1549	0	result = GLOBUS_SUCCESS;
1550	0	break;
1551		}
1552
1553	0	result = GlobusSoapMessageErrorDeserializeFailed(
1554		result, element_qname);
1555	0	goto exit;
1556		}
1557		}
1558
1559	0	while(result == GLOBUS_SUCCESS)
1560		{
1561	0	wst_BinarySecretType                  next;
1562	0	memset(&next, 0, sizeof(wst_BinarySecretType));
1563
1564	0	result = wst_BinarySecretType_deserialize(
1565		element_qname,
1566		&next,
1567		message,
1568		options);
1569	0	if(result != GLOBUS_SUCCESS)
1570		{
1571	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1572		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1573		GlobusSoapMessageStatusFailedWithTextCheck(result))
1574		{
1575	0	result = GLOBUS_SUCCESS;
1576	0	break;
1577		}
1578
1579	0	result = GlobusSoapMessageErrorDeserializeFailed(
1580		result, element_qname);
1581	0	goto exit;
1582		}
1583
1584	0	array->elements = realloc(
1585		array->elements,
1586		(array->length + 1) * sizeof(wst_BinarySecretType));
1587	0	if(!array->elements)
1588		{
1589	0	result = GlobusSoapMessageErrorOutOfMemory;
1590	0	goto exit;
1591		}
1592	0	array->elements[array->length] = next;
1593	0	array->length++;
1594	0	++i;
1595		}
1596
1597		exit:
1598
1599	0	if(result != GLOBUS_SUCCESS)
1600		{
1601	0	int                             di = 0;
1602	0	for(; di < i; ++di)
1603		{
1604	0	wst_BinarySecretType_destroy_contents(
1605		&array->elements[di]);
1606	0	memset(&array->elements[di], 0, sizeof(wst_BinarySecretType));
1607		}
1608		}
1609
1610	0	GlobusSoapMessageDebugExit();
1611	0	return result;