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_TransformsType.h"
21
22		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
23		xsd_QName ds_TransformsType_qname =
24		{
25		DS_TRANSFORMSTYPE_NS,
26		DS_TRANSFORMSTYPE_LOCAL
27		};
28		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
29
30		globus_result_t
31		ds_TransformsType_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_TransformsType_serialize(
38		element_qname,
39		(ds_TransformsType *) instance,
40		message_handle, options);
41		}
42
43		globus_result_t
44		ds_TransformsType_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_TransformsType_deserialize_pointer(
51		element_qname,
52		(ds_TransformsType **) ip,
53		message_handle, options);
54		}
55
56		globus_result_t
57		ds_TransformsType_init_wrapper(void **object)
58	0	{
59	0	return ds_TransformsType_init(
60		(ds_TransformsType **) object);
61		}
62
63		void
64		ds_TransformsType_destroy_wrapper(
65		void *                          object)
66	0	{
67	0	ds_TransformsType_destroy(
68		(ds_TransformsType *) object);
69		}
70
71		globus_result_t
72		ds_TransformsType_copy_wrapper(
73		void **                         dest_obj,
74		void *                          src_obj)
75	0	{
76	0	return ds_TransformsType_copy(
77		(ds_TransformsType **) dest_obj,
78		(ds_TransformsType *) src_obj);
79		}
80
81		globus_result_t
82		ds_TransformsType_init_contents_wrapper(void *object)
83	0	{
84	0	return ds_TransformsType_init_contents(
85		(ds_TransformsType *) object);
86		}
87
88		void
89		ds_TransformsType_destroy_contents_wrapper(
90		void *                          object)
91	0	{
92	0	ds_TransformsType_destroy_contents(
93		(ds_TransformsType *) object);
94		}
95
96		globus_result_t
97		ds_TransformsType_copy_contents_wrapper(
98		void *                          dest_obj,
99		void *                          src_obj)
100	0	{
101	0	return ds_TransformsType_copy_contents(
102		(ds_TransformsType *) dest_obj,
103		(ds_TransformsType *) src_obj);
104		}
105
106		globus_result_t
107		ds_TransformsType_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_TransformsType_serialize_contents(
114		element_qname,
115		(ds_TransformsType *) instance,
116		message_handle, options);
117		}
118
119		globus_result_t
120		ds_TransformsType_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_TransformsType_deserialize_contents_wrapper);
128	0	GlobusSoapMessageDebugEnter();
129
130	0	if(!*instance)
131		{
132	0	result = ds_TransformsType_init(
133		(ds_TransformsType **)instance);
134	0	if(result != GLOBUS_SUCCESS)
135		{
136	0	goto error;
137		}
138		}
139
140	0	result = ds_TransformsType_deserialize_contents(
141		element_qname,
142		*(ds_TransformsType **)instance,
143		message_handle, options);
144		error:
145	0	GlobusSoapMessageDebugExit();
146	0	return result;
147		}
148
149		globus_result_t
150		ds_TransformsType_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_TransformsType_array_serialize(
157		element,
158		(ds_TransformsType_array *) instance,
159		message, options);
160		}
161
162		globus_result_t
163		ds_TransformsType_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_TransformsType_array_init(
174		(ds_TransformsType_array **)inst);
175	0	if(result != GLOBUS_SUCCESS)
176		{
177	0	return result;
178		}
179		}
180
181	0	return ds_TransformsType_array_deserialize(
182		element_qname,
183		*(ds_TransformsType_array **) inst,
184		message, options);
185		}
186
187		globus_result_t
188		ds_TransformsType_array_init_wrapper(
189		void **                             arr)
190	0	{
191	0	return ds_TransformsType_array_init(
192		(ds_TransformsType_array **) arr);
193		}
194
195		void
196		ds_TransformsType_array_destroy_wrapper(
197		void *                              arr)
198	0	{
199	0	ds_TransformsType_array_destroy(
200		(ds_TransformsType_array *) arr);
201		}
202
203		globus_result_t
204		ds_TransformsType_array_copy_wrapper(
205		void **                             dest_arr,
206		void *                              src_arr)
207	0	{
208	0	return ds_TransformsType_array_copy(
209		(ds_TransformsType_array **) dest_arr,
210		(ds_TransformsType_array *) src_arr);
211		}
212
213		globus_result_t
214		ds_TransformsType_array_init_contents_wrapper(
215		void *                              arr)
216	0	{
217	0	return ds_TransformsType_array_init_contents(
218		(ds_TransformsType_array *) arr);
219		}
220
221		void
222		ds_TransformsType_array_destroy_contents_wrapper(
223		void *                              arr)
224	0	{
225	0	ds_TransformsType_array_destroy_contents(
226		(ds_TransformsType_array *) arr);
227		}
228
229		globus_result_t
230		ds_TransformsType_array_copy_contents_wrapper(
231		void *                              dest_arr,
232		void *                              src_arr)
233	0	{
234	0	return ds_TransformsType_array_copy_contents(
235		(ds_TransformsType_array *) dest_arr,
236		(ds_TransformsType_array *) src_arr);
237		}
238
239		struct globus_xsd_type_info_s ds_TransformsType_contents_info =
240		{
241		&ds_TransformsType_qname,
242		ds_TransformsType_serialize_contents_wrapper,
243		ds_TransformsType_deserialize_contents_wrapper,
244		ds_TransformsType_init_wrapper,
245		ds_TransformsType_destroy_wrapper,
246		ds_TransformsType_copy_wrapper,
247		ds_TransformsType_init_contents_wrapper,
248		ds_TransformsType_destroy_contents_wrapper,
249		ds_TransformsType_copy_contents_wrapper,
250		sizeof(ds_TransformsType),
251		NULL,
252		NULL,
253		NULL
254		};
255
256		struct globus_xsd_type_info_s ds_TransformsType_array_info =
257		{
258		&ds_TransformsType_qname,
259		ds_TransformsType_array_serialize_wrapper,
260		ds_TransformsType_array_deserialize_wrapper,
261		ds_TransformsType_array_init_wrapper,
262		ds_TransformsType_array_destroy_wrapper,
263		ds_TransformsType_array_copy_wrapper,
264		ds_TransformsType_array_init_contents_wrapper,
265		ds_TransformsType_array_destroy_contents_wrapper,
266		ds_TransformsType_array_copy_contents_wrapper,
267		sizeof(ds_TransformsType),
268		ds_TransformsType_array_push_wrapper,
269		NULL,
270		NULL
271		};
272
273		struct globus_xsd_type_info_s ds_TransformsType_info =
274		{
275		&ds_TransformsType_qname,
276		ds_TransformsType_serialize_wrapper,
277		ds_TransformsType_deserialize_pointer_wrapper,
278		ds_TransformsType_init_wrapper,
279		ds_TransformsType_destroy_wrapper,
280		ds_TransformsType_copy_wrapper,
281		ds_TransformsType_init_contents_wrapper,
282		ds_TransformsType_destroy_contents_wrapper,
283		ds_TransformsType_copy_contents_wrapper,
284		sizeof(ds_TransformsType),
285		NULL,
286		&ds_TransformsType_contents_info,
287		&ds_TransformsType_array_info
288		};
289
290		globus_result_t
291		ds_TransformsType_init_contents(
292		ds_TransformsType * instance)
293	0	{
294	0	globus_result_t                     result = GLOBUS_SUCCESS;
295	0	GlobusFuncName(ds_TransformsType_init_contents);
296	0	GlobusSoapMessageDebugEnter();
297
298	0	memset(instance, 0, sizeof(ds_TransformsType));
299
300	0	GlobusSoapMessageDebugExit();
301	0	return result;
302		}
303
304		globus_result_t
305		ds_TransformsType_init(
306		ds_TransformsType ** object)
307	0	{
308	0	ds_TransformsType * instance;
309	0	globus_result_t                     result = GLOBUS_SUCCESS;
310	0	GlobusFuncName(ds_TransformsType_init);
311	0	GlobusSoapMessageDebugEnter();
312
313	0	instance = globus_malloc(sizeof(ds_TransformsType));
314	0	if(!instance)
315		{
316	0	result = GlobusSoapMessageErrorOutOfMemory;
317	0	goto exit;
318		}
319
320	0	memset(instance, 0, sizeof(ds_TransformsType));
321
322	0	*object = instance;
323
324		exit:
325	0	GlobusSoapMessageDebugExit();
326	0	return result;
327		}
328
329		void
330		ds_TransformsType_destroy(
331		ds_TransformsType * instance)
332	0	{
333	0	GlobusFuncName(ds_TransformsType_destroy);
334	0	GlobusSoapMessageDebugEnter();
335
336	0	if(!instance)
337		{
338	0	goto exit;
339		}
340
341	0	ds_TransformsType_destroy_contents(instance);
342	0	globus_free(instance);
343
344		exit:
345
346	0	GlobusSoapMessageDebugExit();
347		}
348
349		void
350		ds_TransformsType_destroy_contents(
351		ds_TransformsType * instance)
352	0	{
353	0	GlobusFuncName(ds_TransformsType_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	if(instance)
357		{
358
359
360	0	ds_TransformType_array_destroy_contents(&instance->Transform);
361
362		}
363
364	0	GlobusSoapMessageDebugExit();
365		}
366
367		globus_result_t
368		ds_TransformsType_copy(
369		ds_TransformsType ** dest_obj,
370		const ds_TransformsType * src_obj)
371	0	{
372	0	globus_result_t                     result = GLOBUS_SUCCESS;
373	0	ds_TransformsType * instance;
374	0	GlobusFuncName(ds_TransformsType_copy);
375
376	0	GlobusSoapMessageDebugEnter();
377
378	0	instance = malloc(sizeof(ds_TransformsType));
379	0	if (instance == NULL)
380		{
381	0	GlobusSoapMessageDebugExit();
382	0	return GlobusSoapMessageErrorOutOfMemory;
383		}
384
385	0	result = ds_TransformsType_copy_contents(instance, src_obj);
386	0	if(result != GLOBUS_SUCCESS)
387		{
388	0	globus_free(instance);
389	0	GlobusSoapMessageDebugExit();
390	0	return GlobusSoapMessageErrorOutOfMemory;
391		}
392
393	0	*dest_obj = instance;
394	0	GlobusSoapMessageDebugExit();
395	0	return result;
396		}
397
398		globus_result_t
399		ds_TransformsType_copy_contents(
400		ds_TransformsType * instance,
401		const ds_TransformsType * src_obj)
402	0	{
403	0	globus_result_t                     result = GLOBUS_SUCCESS;
404	0	GlobusFuncName(ds_TransformsType_copy_contents);
405
406	0	GlobusSoapMessageDebugEnter();
407
408
409	0	result = ds_TransformType_array_copy_contents(
410		&instance->Transform,
411		&src_obj->Transform);
412	0	if(result != GLOBUS_SUCCESS)
413		{
414	0	result = GlobusSoapMessageErrorCopyFailed(
415		result, NULL, &ds_TransformType_qname);
416		goto Transform_destroy_array;
417		}
418
419	0	goto exit;
420
421		fail_deserialize:
422	0	ds_TransformType_array_destroy_contents(
423		&instance->Transform);
424
425		Transform_destroy_array:
426
427
428		exit:
429
430	0	GlobusSoapMessageDebugExit();
431	0	return result;
432		}
433
434
435
436		globus_result_t
437		ds_TransformsType_serialize_contents(
438		xsd_QName *                         element_qname, /* ignored */
439		ds_TransformsType * inst,
440		globus_soap_message_handle_t        message_handle,
441		globus_xsd_element_options_t        options)
442	0	{
443	0	globus_result_t                     result = GLOBUS_SUCCESS;
444	0	GlobusFuncName(ds_TransformsType_serialize_contents);
445	0	GlobusSoapMessageDebugEnter();
446
447	0	result = ds_TransformsType_serialize(
448		NULL,
449		inst,
450		message_handle,
451		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
452	0	if(result != GLOBUS_SUCCESS)
453		{
454	0	result = GlobusSoapMessageErrorSerializeFailed(
455		result, NULL, element_qname);
456		goto exit;
457		}
458
459		exit:
460
461	0	GlobusSoapMessageDebugExit();
462	0	return result;
463		}
464
465
466
467		globus_result_t
468		ds_TransformsType_serialize(
469		xsd_QName *                         element_qname,
470		ds_TransformsType * instance,
471		globus_soap_message_handle_t        message_handle,
472		globus_xsd_element_options_t        options)
473	0	{
474	0	globus_result_t                     result = GLOBUS_SUCCESS;
475	0	xsd_QName                           subelement;
476	0	globus_list_t *                     any_attr_keys = NULL;
477	0	globus_list_t *                     any_attr_keys_iterator = NULL;
478	0	xsd_QName *                         type_attr = NULL;
479	0	char *                              prefix = NULL;
480	0	int                                 prefix_created;
481	0	int                                 define_prefix = 0;
482	0	int                                 save_options = options;
483
484	0	GlobusFuncName(ds_TransformsType_serialize);
485	0	GlobusSoapMessageDebugEnter();
486
487
488	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
489		{
490		/* serialize ds_TransformsType element */
491
492	0	result = globus_soap_message_invoke_ns_callouts(
493		message_handle,
494		element_qname,
495		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_SET,
496		&options);
497	0	if(result != GLOBUS_SUCCESS)
498		{
499	0	result = GlobusSoapMessageErrorSerializeFailed(
500		result, NULL, element_qname);
501	0	goto exit;
502		}
503
504	0	result = globus_soap_message_element_ns_set(
505		message_handle,
506		element_qname->Namespace,
507		&options);
508	0	if(result != GLOBUS_SUCCESS)
509		{
510	0	result = GlobusSoapMessageErrorSerializeFailed(
511		result, NULL, element_qname);
512	0	goto exit;
513		}
514
515	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
516		!globus_soap_message_serialize_is_c14n_subset(message_handle))
517		{
518	0	result = globus_soap_message_attribute_ns_set(
519		message_handle,
520		"http://www.w3.org/2001/XMLSchema-instance",
521		&options);
522	0	if(result != GLOBUS_SUCCESS)
523		{
524	0	result = GlobusSoapMessageErrorSerializeFailed(
525		result, NULL, element_qname);
526	0	goto exit;
527		}
528
529	0	result = globus_soap_message_attribute_ns_set(
530		message_handle,
531		ds_TransformsType_qname.Namespace,
532		&options);
533	0	if(result != GLOBUS_SUCCESS)
534		{
535	0	result = GlobusSoapMessageErrorSerializeFailed(
536		result, NULL, element_qname);
537	0	goto exit;
538		}
539		}
540
541	0	result = globus_soap_message_invoke_callouts(
542		message_handle,
543		element_qname,
544		GLOBUS_SOAP_MESSAGE_CALLOUT_BEGIN);
545	0	if(result != GLOBUS_SUCCESS)
546		{
547	0	result = GlobusSoapMessageErrorSerializeFailed(
548		result, NULL, element_qname);
549	0	goto exit;
550		}
551
552	0	result = globus_soap_message_serialize_element(
553		message_handle,
554		element_qname,
555		options,
556		&ds_TransformsType_qname);
557	0	if(result != GLOBUS_SUCCESS)
558		{
559	0	result = GlobusSoapMessageErrorSerializeFailed(
560		result, NULL, element_qname);
561	0	goto exit;
562		}
563
564	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
565		!globus_soap_message_serialize_is_c14n_subset(message_handle))
566		{
567	0	xsd_QName_init(&type_attr);
568
569	0	type_attr->local = globus_libc_strdup("type");
570	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
571		}
572
573		/* serialize namespaces */
574
575	0	result = globus_soap_message_invoke_ns_callouts(
576		message_handle,
577		element_qname,
578		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_ADD,
579		&options);
580	0	if(result != GLOBUS_SUCCESS)
581		{
582	0	result = GlobusSoapMessageErrorSerializeFailed(
583		result, NULL, element_qname);
584	0	goto exit;
585		}
586
587	0	result = globus_soap_message_element_ns_add(
588		message_handle,
589		element_qname->Namespace,
590		&options);
591	0	if(result != GLOBUS_SUCCESS)
592		{
593	0	result = GlobusSoapMessageErrorSerializeFailed(
594		result, NULL, element_qname);
595	0	goto exit;
596		}
597
598	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
599		!globus_soap_message_serialize_is_c14n_subset(message_handle))
600		{
601	0	result = globus_soap_message_attribute_ns_add(
602		message_handle,
603		"http://www.w3.org/2001/XMLSchema-instance",
604		&options);
605	0	if(result != GLOBUS_SUCCESS)
606		{
607	0	result = GlobusSoapMessageErrorSerializeFailed(
608		result, NULL, element_qname);
609	0	goto exit;
610		}
611
612	0	result = globus_soap_message_attribute_ns_add(
613		message_handle,
614		ds_TransformsType_qname.Namespace,
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
624		/* serialize attributes */
625
626	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
627		!globus_soap_message_serialize_is_c14n_subset(message_handle))
628		{
629	0	result = globus_soap_message_serialize_QName_attribute(
630		message_handle,
631		type_attr,
632		&ds_TransformsType_qname);
633	0	if(result != GLOBUS_SUCCESS)
634		{
635	0	result = GlobusSoapMessageErrorSerializeFailed(
636		result, NULL, element_qname);
637	0	goto exit;
638		}
639		}
640
641
642	0	result = globus_soap_message_invoke_callouts(
643		message_handle,
644		element_qname,
645		GLOBUS_SOAP_MESSAGE_CALLOUT_ATTR);
646	0	if(result != GLOBUS_SUCCESS)
647		{
648	0	result = GlobusSoapMessageErrorSerializeFailed(
649		result, NULL, element_qname);
650	0	goto exit;
651		}
652		}
653
654	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
655		{
656	0	result = globus_soap_message_serialize_element_begin_close(
657		message_handle);
658	0	if(result != GLOBUS_SUCCESS)
659		{
660	0	result = GlobusSoapMessageErrorSerializeFailed(
661		result, NULL, element_qname);
662	0	goto exit;
663		}
664		}
665	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
666
667		/* serialize contents of type */
668
669	0	subelement.local = "Transform";
670	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
671
672	0	result = GlobusXSDArrayCheckLowerBounds(
673		1,
674		instance->Transform.length,
675		"Transform");
676	0	if(result != GLOBUS_SUCCESS)
677		{
678	0	result = GlobusSoapMessageErrorSerializeFailed(
679		result, NULL, &ds_TransformType_qname);
680	0	goto exit;
681		}
682
683	0	result = ds_TransformType_array_serialize(
684		&subelement,
685		&instance->Transform,
686		message_handle,
687		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
688	0	if(result != GLOBUS_SUCCESS)
689		{
690	0	result = GlobusSoapMessageErrorSerializeFailed(
691		result, NULL, &ds_TransformType_qname);
692	0	goto exit;
693		}
694
695	0	options = save_options;
696
697	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
698		{
699		/* add end element */
700	0	result = globus_soap_message_serialize_element_end(
701		message_handle,
702		element_qname,
703		options,
704		&ds_TransformsType_qname);
705	0	if(result != GLOBUS_SUCCESS)
706		{
707	0	result = GlobusSoapMessageErrorSerializeFailed(
708		result, NULL, element_qname);
709	0	goto exit;
710		}
711
712	0	globus_soap_message_element_ns_remove(
713		message_handle,
714		element_qname->Namespace,
715		&options);
716
717		/* remove namespace/prefix mappings for these types */
718
719	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
720		!globus_soap_message_serialize_is_c14n_subset(message_handle))
721		{
722	0	globus_soap_message_attribute_ns_remove(
723		message_handle,
724		"http://www.w3.org/2001/XMLSchema-instance",
725		&options);
726
727	0	globus_soap_message_attribute_ns_remove(
728		message_handle,
729		ds_TransformsType_qname.Namespace,
730		&options);
731		}
732
733	0	result = globus_soap_message_invoke_ns_callouts(
734		message_handle,
735		element_qname,
736		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_REMOVE,
737		&options);
738	0	if(result != GLOBUS_SUCCESS)
739		{
740	0	result  = GlobusSoapMessageErrorSerializeFailed(
741		result, NULL, element_qname);
742	0	goto exit;
743		}
744
745	0	result = globus_soap_message_invoke_callouts(
746		message_handle,
747		element_qname,
748		GLOBUS_SOAP_MESSAGE_CALLOUT_END);
749	0	if(result != GLOBUS_SUCCESS)
750		{
751	0	result = GlobusSoapMessageErrorSerializeFailed(
752		result, NULL, element_qname);
753		goto exit;
754		}
755		}
756
757		exit:
758	0	if (type_attr)
759		{
760	0	xsd_QName_destroy(type_attr);
761		}
762
763	0	if(any_attr_keys)
764		{
765	0	globus_list_free(any_attr_keys);
766		}
767
768	0	GlobusSoapMessageDebugExit();
769	0	return result;
770		}
771
772
773
774		globus_result_t
775		ds_TransformsType_deserialize_contents(
776		xsd_QName *                         element_qname, /* ignored */
777		ds_TransformsType * inst,
778		globus_soap_message_handle_t        message_handle,
779		globus_xsd_element_options_t        options)
780	0	{
781	0	globus_result_t                     result = GLOBUS_SUCCESS;
782	0	GlobusFuncName(ds_TransformsType_deserialize_contents);
783	0	GlobusSoapMessageDebugEnter();
784
785	0	result = ds_TransformsType_deserialize(
786		NULL,
787		inst,
788		message_handle,
789		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
790	0	if(result != GLOBUS_SUCCESS)
791		{
792	0	result = GlobusSoapMessageErrorDeserializeFailed(
793		result, element_qname);
794		goto exit;
795		}
796
797		exit:
798
799	0	GlobusSoapMessageDebugExit();
800	0	return result;
801		}
802
803
804
805		globus_result_t
806		ds_TransformsType_deserialize(
807		xsd_QName *                         element_qname,
808		ds_TransformsType * instance,
809		globus_soap_message_handle_t        message_handle,
810		globus_xsd_element_options_t        options)
811	0	{
812	0	globus_result_t                     result = GLOBUS_SUCCESS;
813	0	xsd_QName                           subelement;
814	0	GlobusFuncName(ds_TransformsType_deserialize);
815	0	GlobusSoapMessageDebugEnter();
816
817
818	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
819		{
820	0	result = globus_soap_message_deserialize_element(
821		message_handle, element_qname);
822	0	if(result != GLOBUS_SUCCESS)
823		{
824	0	result = GlobusSoapMessageErrorDeserializeFailed(
825		result, element_qname);
826	0	goto exit;
827		}
828
829
830	0	result = globus_soap_message_deserialize_element_begin_close(
831		message_handle);
832	0	if(result != GLOBUS_SUCCESS)
833		{
834	0	result = GlobusSoapMessageErrorDeserializeFailed(
835		result, element_qname);
836	0	goto fail_deserialize;
837		}
838		}
839
840	0	subelement.local = "Transform";
841	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
842
843	0	result = ds_TransformType_array_deserialize(
844		&subelement,
845		&instance->Transform,
846		message_handle,
847		0);
848	0	if(result != GLOBUS_SUCCESS)
849		{
850	0	result = GlobusSoapMessageErrorDeserializeFailed(
851		result,
852		(&subelement));
853	0	goto Transform_destroy_array;
854		}
855
856	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
857		{
858	0	result = globus_soap_message_deserialize_element_end(
859		message_handle,
860		element_qname);
861	0	if(result != GLOBUS_SUCCESS)
862		{
863	0	result = GlobusSoapMessageErrorDeserializeFailed(
864		result, element_qname);
865		goto fail_deserialize;
866		}
867		}
868
869	0	goto exit;
870
871		fail_deserialize:
872	0	ds_TransformType_array_destroy_contents(
873		&instance->Transform);
874
875		Transform_destroy_array:
876
877
878		exit:
879
880	0	GlobusSoapMessageDebugExit();
881	0	return result;
882		}
883
884
885
886		globus_result_t
887		ds_TransformsType_deserialize_pointer(
888		xsd_QName *                         element_qname,
889		ds_TransformsType ** ip,
890		globus_soap_message_handle_t        message_handle,
891		globus_xsd_element_options_t        options)
892	0	{
893	0	ds_TransformsType * instance = NULL;
894	0	globus_result_t                     result = GLOBUS_SUCCESS;
895	0	xsd_QName                           subelement;
896	0	int                                 found_attrs = 0;
897	0	int                                 empty_element = 0;
898	0	GlobusFuncName(ds_TransformsType_deserialize_pointer);
899	0	GlobusSoapMessageDebugEnter();
900
901	0	*ip = NULL;
902
903	0	result = globus_soap_message_deserialize_element(
904		message_handle, element_qname);
905	0	if(result != GLOBUS_SUCCESS &&
906		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
907		GlobusSoapMessageStatusFailedElementCheck(result) ||
908		GlobusSoapMessageStatusFailedWithTextCheck(result)))
909		{
910	0	*ip = NULL;
911	0	result = GLOBUS_SUCCESS;
912	0	goto exit;
913		}
914
915	0	if(result != GLOBUS_SUCCESS)
916		{
917	0	result = GlobusSoapMessageErrorDeserializeFailed(
918		result, element_qname);
919	0	goto exit;
920		}
921
922	0	if(globus_soap_message_deserialize_element_is_empty(
923		message_handle))
924		{
925	0	empty_element = 1;
926		}
927
928
929
930	0	result = ds_TransformsType_init(&instance);
931	0	if(result != GLOBUS_SUCCESS)
932		{
933	0	result = GlobusSoapMessageErrorDeserializeFailed(
934		result, element_qname);
935	0	goto exit;
936		}
937
938
939	0	if(found_attrs == 0 &&
940		globus_soap_message_deserialize_element_is_nil(message_handle))
941		{
942	0	ds_TransformsType_destroy(instance);
943
944	0	result = globus_soap_message_deserialize_element_end(
945		message_handle,
946		element_qname);
947	0	if(result != GLOBUS_SUCCESS)
948		{
949	0	result = GlobusSoapMessageErrorDeserializeFailed(
950		result, element_qname);
951	0	goto exit;
952		}
953
954	0	*ip = NULL;
955	0	globus_object_free(globus_error_get(result));
956	0	result = GLOBUS_SUCCESS;
957	0	goto exit;
958		}
959
960
961	0	if(empty_element)
962		{
963	0	result = globus_soap_message_deserialize_element_end(
964		message_handle,
965		element_qname);
966	0	if(result != GLOBUS_SUCCESS)
967		{
968	0	result = GlobusSoapMessageErrorDeserializeFailed(
969		result, element_qname);
970	0	goto fail_deserialize;
971		}
972
973	0	*ip = instance;
974	0	goto exit;
975		}
976
977	0	result = globus_soap_message_deserialize_element_begin_close(
978		message_handle);
979	0	if(result != GLOBUS_SUCCESS)
980		{
981	0	result = GlobusSoapMessageErrorDeserializeFailed(
982		result, element_qname);
983	0	goto exit;
984		}
985
986
987	0	subelement.local = "Transform";
988	0	subelement.Namespace = "http://www.w3.org/2000/09/xmldsig#";
989
990	0	result = ds_TransformType_array_deserialize(
991		&subelement,
992		&instance->Transform,
993		message_handle,
994		0);
995	0	if(result != GLOBUS_SUCCESS)
996		{
997	0	result = GlobusSoapMessageErrorDeserializeFailed(
998		result,
999		(&subelement));
1000	0	goto Transform_destroy_array;
1001		}
1002
1003
1004	0	result = globus_soap_message_deserialize_element_end(
1005		message_handle,
1006		element_qname);
1007	0	if(result != GLOBUS_SUCCESS)
1008		{
1009	0	result = GlobusSoapMessageErrorDeserializeFailed(
1010		result, element_qname);
1011	0	goto fail_deserialize;
1012		}
1013
1014	0	*ip = instance;
1015
1016	0	goto exit;
1017
1018		fail_deserialize:
1019	0	ds_TransformType_array_destroy_contents(
1020		&instance->Transform);
1021
1022		Transform_destroy_array:
1023
1024		exit:
1025
1026	0	GlobusSoapMessageDebugExit();
1027	0	return result;
1028		}
1029
1030
1031		globus_result_t
1032		ds_TransformsType_array_init_contents(
1033		ds_TransformsType_array * array)
1034	0	{
1035	0	GlobusFuncName(ds_TransformsType_array_init_contents);
1036	0	GlobusSoapMessageDebugEnter();
1037
1038	0	memset(array, 0, sizeof(ds_TransformsType_array));
1039
1040	0	GlobusSoapMessageDebugExit();
1041	0	return GLOBUS_SUCCESS;
1042		}
1043
1044		globus_result_t
1045		ds_TransformsType_array_init(
1046		ds_TransformsType_array ** arr)
1047	0	{
1048	0	ds_TransformsType_array * array;
1049	0	globus_result_t                     result;
1050	0	GlobusFuncName(ds_TransformsType_array_init);
1051	0	GlobusSoapMessageDebugEnter();
1052
1053	0	array = (ds_TransformsType_array *)
1054		globus_malloc(sizeof(ds_TransformsType_array));
1055	0	if(!array)
1056		{
1057	0	result = GlobusSoapMessageErrorOutOfMemory;
1058	0	goto exit;
1059		}
1060
1061	0	result = ds_TransformsType_array_init_contents(array);
1062	0	if(result != GLOBUS_SUCCESS)
1063		{
1064	0	globus_free(array);
1065	0	array = NULL;
1066
1067		}
1068
1069	0	*arr = array;
1070
1071		exit:
1072	0	GlobusSoapMessageDebugExit();
1073	0	return result;
1074		}
1075
1076		void
1077		ds_TransformsType_array_destroy_contents(
1078		ds_TransformsType_array * array)
1079	0	{
1080	0	int                                 i = 0;
1081	0	GlobusFuncName(ds_TransformsType_array_destroy_contents);
1082	0	GlobusSoapMessageDebugEnter();
1083
1084	0	for(; i < array->length; ++i)
1085		{
1086	0	ds_TransformsType_destroy_contents(&array->elements[i]);
1087		}
1088
1089	0	if(array->elements)
1090		{
1091	0	globus_free(array->elements);
1092	0	array->elements = NULL;
1093		}
1094	0	array->length = 0;
1095
1096	0	GlobusSoapMessageDebugExit();
1097		}
1098
1099		void
1100		ds_TransformsType_array_destroy(
1101		ds_TransformsType_array * array)
1102	0	{
1103	0	GlobusFuncName(ds_TransformsType_array_destroy);
1104	0	GlobusSoapMessageDebugEnter();
1105
1106	0	ds_TransformsType_array_destroy_contents(array);
1107	0	globus_free(array);
1108
1109	0	GlobusSoapMessageDebugExit();
1110		}
1111
1112		globus_result_t
1113		ds_TransformsType_array_copy(
1114		ds_TransformsType_array ** dest_arr,
1115		const ds_TransformsType_array * src_arr)
1116	0	{
1117	0	ds_TransformsType_array * array;
1118	0	globus_result_t                     result;
1119	0	GlobusFuncName(ds_TransformsType_array_copy);
1120	0	GlobusSoapMessageDebugEnter();
1121
1122	0	array = (ds_TransformsType_array *) globus_malloc(
1123		sizeof(ds_TransformsType_array));
1124	0	if(!array)
1125		{
1126	0	result = GlobusSoapMessageErrorOutOfMemory;
1127	0	GlobusSoapMessageDebugExit();
1128	0	return result;
1129		}
1130
1131	0	result = ds_TransformsType_array_copy_contents(array, src_arr);
1132	0	if(result != GLOBUS_SUCCESS)
1133		{
1134	0	globus_free(array);
1135	0	GlobusSoapMessageDebugExit();
1136	0	return result;
1137		}
1138
1139	0	*dest_arr = array;
1140
1141	0	GlobusSoapMessageDebugExit();
1142	0	return GLOBUS_SUCCESS;
1143		}
1144
1145		globus_result_t
1146		ds_TransformsType_array_copy_contents(
1147		ds_TransformsType_array * dest_arr,
1148		const ds_TransformsType_array * src_arr)
1149	0	{
1150	0	int                                 i;
1151	0	globus_result_t                     result = GLOBUS_SUCCESS;
1152	0	GlobusFuncName(ds_TransformsType_array_copy_contents);
1153	0	GlobusSoapMessageDebugEnter();
1154
1155	0	dest_arr->length = src_arr->length;
1156	0	if(dest_arr->length > 0)
1157		{
1158	0	dest_arr->elements = (ds_TransformsType *) malloc(
1159		sizeof(ds_TransformsType) * dest_arr->length);
1160	0	if(!dest_arr->elements)
1161		{
1162	0	result = GlobusSoapMessageErrorOutOfMemory;
1163	0	GlobusSoapMessageDebugExit();
1164	0	return result;
1165		}
1166		}
1167		else
1168		{
1169	0	dest_arr->elements = NULL;
1170		}
1171
1172	0	for(i = 0; i < dest_arr->length; i++)
1173		{
1174	0	result = ds_TransformsType_copy_contents(
1175		&dest_arr->elements[i], &src_arr->elements[i]);
1176	0	if(result != GLOBUS_SUCCESS)
1177		{
1178	0	while(i--)
1179		{
1180	0	ds_TransformsType_destroy_contents(&dest_arr->elements[i]);
1181		}
1182
1183	0	globus_free(dest_arr->elements);
1184	0	dest_arr->elements = NULL;
1185	0	dest_arr->length = 0;
1186	0	break;
1187		}
1188		}
1189
1190	0	GlobusSoapMessageDebugExit();
1191	0	return result;
1192		}
1193
1194		ds_TransformsType *
1195		ds_TransformsType_array_push(
1196		ds_TransformsType_array * array)
1197	0	{
1198	0	GlobusFuncName(ds_TransformsType_array_push);
1199	0	GlobusSoapMessageDebugEnter();
1200
1201	0	array->elements = realloc(array->elements,
1202		sizeof(ds_TransformsType) *
1203		(array->length + 1));
1204	0	memset(&array->elements[array->length], 0, sizeof(ds_TransformsType));
1205	0	array->length++;
1206
1207	0	GlobusSoapMessageDebugExit();
1208	0	return (&array->elements[array->length - 1]);
1209		}
1210
1211		void *
1212		ds_TransformsType_array_push_wrapper(
1213		void * array)
1214	0	{
1215	0	return (void *) ds_TransformsType_array_push((ds_TransformsType_array *) array);
1216		}
1217
1218		globus_result_t
1219		ds_TransformsType_array_serialize(
1220		xsd_QName *                         element_qname,
1221		ds_TransformsType_array * array,
1222		globus_soap_message_handle_t        message,
1223		globus_xsd_element_options_t        options)
1224	0	{
1225	0	globus_result_t                     result = GLOBUS_SUCCESS;
1226	0	int                                 i = 0;
1227	0	GlobusFuncName(ds_TransformsType_array_serialize);
1228	0	GlobusSoapMessageDebugEnter();
1229
1230	0	for(; i < array->length; ++i)
1231		{
1232	0	result = ds_TransformsType_serialize(
1233		element_qname,
1234		&array->elements[i],
1235		message,
1236		options);
1237	0	if(result != GLOBUS_SUCCESS)
1238		{
1239	0	goto exit;
1240		}
1241		}
1242
1243		exit:
1244
1245	0	GlobusSoapMessageDebugExit();
1246	0	return result;
1247		}
1248
1249		globus_result_t
1250		ds_TransformsType_array_deserialize(
1251		xsd_QName *                         element_qname,
1252		ds_TransformsType_array * array,
1253		globus_soap_message_handle_t        message,
1254		globus_xsd_element_options_t        options)
1255	0	{
1256	0	globus_result_t                     result = GLOBUS_SUCCESS;
1257	0	int                                 i = 0;
1258	0	int                                 pre_length;
1259	0	GlobusFuncName(ds_TransformsType_array_deserialize);
1260	0	GlobusSoapMessageDebugEnter();
1261
1262	0	pre_length = array->length;
1263
1264	0	for(i = 0; i < pre_length; ++i)
1265		{
1266	0	result = ds_TransformsType_deserialize(
1267		element_qname,
1268		&array->elements[i],
1269		message,
1270		options);
1271	0	if(result != GLOBUS_SUCCESS)
1272		{
1273	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1274		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1275		GlobusSoapMessageStatusFailedWithTextCheck(result))
1276		{
1277	0	result = GLOBUS_SUCCESS;
1278	0	break;
1279		}
1280
1281	0	result = GlobusSoapMessageErrorDeserializeFailed(
1282		result, element_qname);
1283	0	goto exit;
1284		}
1285		}
1286
1287	0	while(result == GLOBUS_SUCCESS)
1288		{
1289	0	ds_TransformsType                  next;
1290	0	memset(&next, 0, sizeof(ds_TransformsType));
1291
1292	0	result = ds_TransformsType_deserialize(
1293		element_qname,
1294		&next,
1295		message,
1296		options);
1297	0	if(result != GLOBUS_SUCCESS)
1298		{
1299	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1300		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1301		GlobusSoapMessageStatusFailedWithTextCheck(result))
1302		{
1303	0	result = GLOBUS_SUCCESS;
1304	0	break;
1305		}
1306
1307	0	result = GlobusSoapMessageErrorDeserializeFailed(
1308		result, element_qname);
1309	0	goto exit;
1310		}
1311
1312	0	array->elements = realloc(
1313		array->elements,
1314		(array->length + 1) * sizeof(ds_TransformsType));
1315	0	if(!array->elements)
1316		{
1317	0	result = GlobusSoapMessageErrorOutOfMemory;
1318	0	goto exit;
1319		}
1320	0	array->elements[array->length] = next;
1321	0	array->length++;
1322	0	++i;
1323		}
1324
1325		exit:
1326
1327	0	if(result != GLOBUS_SUCCESS)
1328		{
1329	0	int                             di = 0;
1330	0	for(; di < i; ++di)
1331		{
1332	0	ds_TransformsType_destroy_contents(
1333		&array->elements[di]);
1334	0	memset(&array->elements[di], 0, sizeof(ds_TransformsType));
1335		}
1336		}
1337
1338	0	GlobusSoapMessageDebugExit();
1339	0	return result;