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