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