1		/*
2		* Copyright 1999-2006 University of Chicago
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17
18		/*
19		* This file is automatically generated by the Globus WSDLtoC converter
20		*/
21
22		#include "xsd_QName.h"
23		#include "globus_soap_message.h"
24		#include "globus_xsd_type_info.h"
25		#include "wssg_ServiceGroupRPType.h"
26
27		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
28		xsd_QName wssg_ServiceGroupRPType_qname =
29		{
30		WSSG_SERVICEGROUPRPTYPE_NS,
31		WSSG_SERVICEGROUPRPTYPE_LOCAL
32		};
33		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
34
35		globus_result_t
36		wssg_ServiceGroupRPType_serialize_wrapper(
37		const xsd_QName *                   element_qname,
38		const void *                        instance,
39		globus_soap_message_handle_t        message_handle,
40		globus_xsd_element_options_t        options)
41	0	{
42	0	return wssg_ServiceGroupRPType_serialize(
43		element_qname,
44		(const wssg_ServiceGroupRPType *) instance,
45		message_handle, options);
46		}
47
48		globus_result_t
49		wssg_ServiceGroupRPType_deserialize_pointer_wrapper(
50		const xsd_QName *                   element_qname,
51		void **                             ip,
52		globus_soap_message_handle_t        message_handle,
53		globus_xsd_element_options_t        options)
54	0	{
55	0	return wssg_ServiceGroupRPType_deserialize_pointer(
56		element_qname,
57		(wssg_ServiceGroupRPType **) ip,
58		message_handle, options);
59		}
60
61		globus_result_t
62		wssg_ServiceGroupRPType_init_wrapper(void **object)
63	0	{
64	0	return wssg_ServiceGroupRPType_init(
65		(wssg_ServiceGroupRPType **) object);
66		}
67
68		void
69		wssg_ServiceGroupRPType_destroy_wrapper(
70		void *                          object)
71	0	{
72	0	wssg_ServiceGroupRPType_destroy(
73		(wssg_ServiceGroupRPType *) object);
74		}
75
76		globus_result_t
77		wssg_ServiceGroupRPType_copy_wrapper(
78		void **                         dest_obj,
79		const void *                    src_obj)
80	0	{
81	0	return wssg_ServiceGroupRPType_copy(
82		(wssg_ServiceGroupRPType **) dest_obj,
83		(wssg_ServiceGroupRPType *) src_obj);
84		}
85
86		globus_result_t
87		wssg_ServiceGroupRPType_init_contents_wrapper(void *object)
88	0	{
89	0	return wssg_ServiceGroupRPType_init_contents(
90		(wssg_ServiceGroupRPType *) object);
91		}
92
93		void
94		wssg_ServiceGroupRPType_destroy_contents_wrapper(
95		void *                          object)
96	0	{
97	0	wssg_ServiceGroupRPType_destroy_contents(
98		(wssg_ServiceGroupRPType *) object);
99		}
100
101		globus_result_t
102		wssg_ServiceGroupRPType_copy_contents_wrapper(
103		void *                          dest_obj,
104		const void *                    src_obj)
105	0	{
106	0	return wssg_ServiceGroupRPType_copy_contents(
107		(wssg_ServiceGroupRPType *) dest_obj,
108		(const wssg_ServiceGroupRPType *) src_obj);
109		}
110
111		globus_result_t
112		wssg_ServiceGroupRPType_serialize_contents_wrapper(
113		const xsd_QName *                   element_qname,
114		const void *                        instance,
115		globus_soap_message_handle_t        message_handle,
116		globus_xsd_element_options_t        options)
117	0	{
118	0	return wssg_ServiceGroupRPType_serialize_contents(
119		element_qname,
120		(wssg_ServiceGroupRPType *) instance,
121		message_handle, options);
122		}
123
124		globus_result_t
125		wssg_ServiceGroupRPType_deserialize_contents_wrapper(
126		const xsd_QName *                   element_qname,
127		void **                             instance,
128		globus_soap_message_handle_t        message_handle,
129		globus_xsd_element_options_t        options)
130	0	{
131	0	globus_result_t                     result;
132	0	GlobusFuncName(wssg_ServiceGroupRPType_deserialize_contents_wrapper);
133	0	GlobusSoapMessageDebugEnter();
134
135	0	if(!*instance)
136		{
137	0	result = wssg_ServiceGroupRPType_init(
138		(wssg_ServiceGroupRPType **)instance);
139	0	if(result != GLOBUS_SUCCESS)
140		{
141	0	goto error;
142		}
143		}
144
145	0	result = wssg_ServiceGroupRPType_deserialize_contents(
146		element_qname,
147		*(wssg_ServiceGroupRPType **)instance,
148		message_handle, options);
149		error:
150	0	GlobusSoapMessageDebugExit();
151	0	return result;
152		}
153
154		globus_result_t
155		wssg_ServiceGroupRPType_array_serialize_wrapper(
156		const xsd_QName *               element,
157		const void *                    instance,
158		globus_soap_message_handle_t    message,
159		globus_xsd_element_options_t    options)
160	0	{
161	0	return wssg_ServiceGroupRPType_array_serialize(
162		element,
163		(wssg_ServiceGroupRPType_array *) instance,
164		message, options);
165		}
166
167		globus_result_t
168		wssg_ServiceGroupRPType_array_deserialize_wrapper(
169		const xsd_QName *                   element_qname,
170		void **                             inst,
171		globus_soap_message_handle_t        message,
172		globus_xsd_element_options_t        options)
173	0	{
174	0	if(!*inst)
175		{
176	0	globus_result_t                 result;
177
178	0	result = wssg_ServiceGroupRPType_array_init(
179		(wssg_ServiceGroupRPType_array **)inst);
180	0	if(result != GLOBUS_SUCCESS)
181		{
182	0	return result;
183		}
184		}
185
186	0	return wssg_ServiceGroupRPType_array_deserialize(
187		element_qname,
188		*(wssg_ServiceGroupRPType_array **) inst,
189		message, options);
190		}
191
192		globus_result_t
193		wssg_ServiceGroupRPType_array_init_wrapper(
194		void **                             arr)
195	0	{
196	0	return wssg_ServiceGroupRPType_array_init(
197		(wssg_ServiceGroupRPType_array **) arr);
198		}
199
200		void
201		wssg_ServiceGroupRPType_array_destroy_wrapper(
202		void *                              arr)
203	0	{
204	0	wssg_ServiceGroupRPType_array_destroy(
205		(wssg_ServiceGroupRPType_array *) arr);
206		}
207
208		globus_result_t
209		wssg_ServiceGroupRPType_array_copy_wrapper(
210		void **                             dest_arr,
211		const void *                        src_arr)
212	0	{
213	0	return wssg_ServiceGroupRPType_array_copy(
214		(wssg_ServiceGroupRPType_array **) dest_arr,
215		(const wssg_ServiceGroupRPType_array *) src_arr);
216		}
217
218		globus_result_t
219		wssg_ServiceGroupRPType_array_init_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	return wssg_ServiceGroupRPType_array_init_contents(
223		(wssg_ServiceGroupRPType_array *) arr);
224		}
225
226		void
227		wssg_ServiceGroupRPType_array_destroy_contents_wrapper(
228		void *                              arr)
229	0	{
230	0	wssg_ServiceGroupRPType_array_destroy_contents(
231		(wssg_ServiceGroupRPType_array *) arr);
232		}
233
234		globus_result_t
235		wssg_ServiceGroupRPType_array_copy_contents_wrapper(
236		void *                              dest_arr,
237		const void *                        src_arr)
238	0	{
239	0	return wssg_ServiceGroupRPType_array_copy_contents(
240		(wssg_ServiceGroupRPType_array *) dest_arr,
241		(const wssg_ServiceGroupRPType_array *) src_arr);
242		}
243
244		struct globus_xsd_type_info_s wssg_ServiceGroupRPType_contents_info =
245		{
246		&wssg_ServiceGroupRPType_qname,
247		wssg_ServiceGroupRPType_serialize_contents_wrapper,
248		wssg_ServiceGroupRPType_deserialize_contents_wrapper,
249		wssg_ServiceGroupRPType_init_wrapper,
250		wssg_ServiceGroupRPType_destroy_wrapper,
251		wssg_ServiceGroupRPType_copy_wrapper,
252		wssg_ServiceGroupRPType_init_contents_wrapper,
253		wssg_ServiceGroupRPType_destroy_contents_wrapper,
254		wssg_ServiceGroupRPType_copy_contents_wrapper,
255		sizeof(wssg_ServiceGroupRPType),
256		NULL,
257		NULL,
258		NULL
259		};
260
261		struct globus_xsd_type_info_s wssg_ServiceGroupRPType_array_info =
262		{
263		&wssg_ServiceGroupRPType_qname,
264		wssg_ServiceGroupRPType_array_serialize_wrapper,
265		wssg_ServiceGroupRPType_array_deserialize_wrapper,
266		wssg_ServiceGroupRPType_array_init_wrapper,
267		wssg_ServiceGroupRPType_array_destroy_wrapper,
268		wssg_ServiceGroupRPType_array_copy_wrapper,
269		wssg_ServiceGroupRPType_array_init_contents_wrapper,
270		wssg_ServiceGroupRPType_array_destroy_contents_wrapper,
271		wssg_ServiceGroupRPType_array_copy_contents_wrapper,
272		sizeof(wssg_ServiceGroupRPType),
273		wssg_ServiceGroupRPType_array_push_wrapper,
274		NULL,
275		NULL
276		};
277
278		struct globus_xsd_type_info_s wssg_ServiceGroupRPType_info =
279		{
280		&wssg_ServiceGroupRPType_qname,
281		wssg_ServiceGroupRPType_serialize_wrapper,
282		wssg_ServiceGroupRPType_deserialize_pointer_wrapper,
283		wssg_ServiceGroupRPType_init_wrapper,
284		wssg_ServiceGroupRPType_destroy_wrapper,
285		wssg_ServiceGroupRPType_copy_wrapper,
286		wssg_ServiceGroupRPType_init_contents_wrapper,
287		wssg_ServiceGroupRPType_destroy_contents_wrapper,
288		wssg_ServiceGroupRPType_copy_contents_wrapper,
289		sizeof(wssg_ServiceGroupRPType),
290		NULL,
291		&wssg_ServiceGroupRPType_contents_info,
292		&wssg_ServiceGroupRPType_array_info
293		};
294
295		globus_result_t
296		wssg_ServiceGroupRPType_init_contents(
297		wssg_ServiceGroupRPType * instance)
298	0	{
299	0	globus_result_t                     result = GLOBUS_SUCCESS;
300	0	GlobusFuncName(wssg_ServiceGroupRPType_init_contents);
301	0	GlobusSoapMessageDebugEnter();
302
303	0	memset(instance, 0, sizeof(wssg_ServiceGroupRPType));
304
305	0	GlobusSoapMessageDebugExit();
306	0	return result;
307		}
308
309		globus_result_t
310		wssg_ServiceGroupRPType_init(
311		wssg_ServiceGroupRPType ** object)
312	0	{
313	0	wssg_ServiceGroupRPType * instance;
314	0	globus_result_t                     result = GLOBUS_SUCCESS;
315	0	GlobusFuncName(wssg_ServiceGroupRPType_init);
316	0	GlobusSoapMessageDebugEnter();
317
318	0	instance = globus_malloc(sizeof(wssg_ServiceGroupRPType));
319	0	if(!instance)
320		{
321	0	result = GlobusSoapMessageErrorOutOfMemory;
322	0	goto exit;
323		}
324
325	0	memset(instance, 0, sizeof(wssg_ServiceGroupRPType));
326
327	0	*object = instance;
328
329		exit:
330	0	GlobusSoapMessageDebugExit();
331	0	return result;
332		}
333
334		void
335		wssg_ServiceGroupRPType_destroy(
336		wssg_ServiceGroupRPType * instance)
337	0	{
338	0	GlobusFuncName(wssg_ServiceGroupRPType_destroy);
339	0	GlobusSoapMessageDebugEnter();
340
341	0	if(!instance)
342		{
343	0	goto exit;
344		}
345
346	0	wssg_ServiceGroupRPType_destroy_contents(instance);
347	0	globus_free(instance);
348
349		exit:
350
351	0	GlobusSoapMessageDebugExit();
352		}
353
354
355		void
356		wssg_ServiceGroupRPType_destroy_contents(
357		wssg_ServiceGroupRPType * instance)
358	0	{
359	0	GlobusFuncName(wssg_ServiceGroupRPType_destroy_contents);
360	0	GlobusSoapMessageDebugEnter();
361
362	0	if(instance)
363		{
364
365
366	0	wssg_MembershipContentRuleType_array_destroy_contents(&instance->MembershipContentRule);
367
368	0	wssg_EntryType_array_destroy_contents(&instance->Entry);
369
370		}
371
372	0	GlobusSoapMessageDebugExit();
373		}
374
375
376		globus_result_t
377		wssg_ServiceGroupRPType_copy(
378		wssg_ServiceGroupRPType ** dest_obj,
379		const wssg_ServiceGroupRPType * src_obj)
380	0	{
381	0	globus_result_t                     result = GLOBUS_SUCCESS;
382	0	wssg_ServiceGroupRPType * instance;
383	0	GlobusFuncName(wssg_ServiceGroupRPType_copy);
384
385	0	GlobusSoapMessageDebugEnter();
386
387	0	instance = calloc(1, sizeof(wssg_ServiceGroupRPType));
388	0	if (instance == NULL)
389		{
390	0	GlobusSoapMessageDebugExit();
391	0	return GlobusSoapMessageErrorOutOfMemory;
392		}
393
394	0	result = wssg_ServiceGroupRPType_copy_contents(instance, src_obj);
395	0	if(result != GLOBUS_SUCCESS)
396		{
397	0	globus_free(instance);
398	0	GlobusSoapMessageDebugExit();
399	0	return GlobusSoapMessageErrorOutOfMemory;
400		}
401
402	0	*dest_obj = instance;
403	0	GlobusSoapMessageDebugExit();
404	0	return result;
405		}
406
407		globus_result_t
408		wssg_ServiceGroupRPType_copy_contents(
409		wssg_ServiceGroupRPType * instance,
410		const wssg_ServiceGroupRPType * src_obj)
411	0	{
412	0	globus_result_t                     result = GLOBUS_SUCCESS;
413	0	GlobusFuncName(wssg_ServiceGroupRPType_copy_contents);
414
415	0	GlobusSoapMessageDebugEnter();
416
417	0	result = wssg_MembershipContentRuleType_array_copy_contents(
418		&instance->MembershipContentRule,
419		&src_obj->MembershipContentRule);
420	0	if(result != GLOBUS_SUCCESS)
421		{
422	0	result = GlobusSoapMessageErrorCopyFailed(
423		result, NULL, &wssg_MembershipContentRuleType_qname);
424	0	goto MembershipContentRule_destroy_array;
425		}
426
427	0	result = wssg_EntryType_array_copy_contents(
428		&instance->Entry,
429		&src_obj->Entry);
430	0	if(result != GLOBUS_SUCCESS)
431		{
432	0	result = GlobusSoapMessageErrorCopyFailed(
433		result, NULL, &wssg_EntryType_qname);
434		goto Entry_destroy_array;
435		}
436
437	0	goto exit;
438
439		fail_deserialize:
440	0	wssg_EntryType_array_destroy_contents(
441		&instance->Entry);
442
443		Entry_destroy_array:
444	0	wssg_MembershipContentRuleType_array_destroy_contents(
445		&instance->MembershipContentRule);
446
447		MembershipContentRule_destroy_array:
448
449
450		exit:
451
452	0	GlobusSoapMessageDebugExit();
453	0	return result;
454		}
455
456
457
458		globus_result_t
459		wssg_ServiceGroupRPType_serialize_contents(
460		const xsd_QName *                   element_qname, /* ignored */
461		const wssg_ServiceGroupRPType *              inst,
462		globus_soap_message_handle_t        message_handle,
463		globus_xsd_element_options_t        options)
464	0	{
465	0	globus_result_t                     result = GLOBUS_SUCCESS;
466	0	GlobusFuncName(wssg_ServiceGroupRPType_serialize_contents);
467	0	GlobusSoapMessageDebugEnter();
468
469	0	result = wssg_ServiceGroupRPType_serialize(
470		NULL,
471		inst,
472		message_handle,
473		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
474	0	if(result != GLOBUS_SUCCESS)
475		{
476	0	result = GlobusSoapMessageErrorSerializeFailed(
477		result, NULL, element_qname);
478		goto exit;
479		}
480
481		exit:
482
483	0	GlobusSoapMessageDebugExit();
484	0	return result;
485		}
486
487
488
489		globus_result_t
490		wssg_ServiceGroupRPType_serialize(
491		const xsd_QName *                   element_qname,
492		const wssg_ServiceGroupRPType *              instance,
493		globus_soap_message_handle_t        message_handle,
494		globus_xsd_element_options_t        options)
495	0	{
496	0	globus_result_t                     result = GLOBUS_SUCCESS;
497	0	xsd_QName                           subelement;
498	0	globus_list_t *                     any_attr_keys = NULL;
499	0	globus_list_t *                     any_attr_keys_iterator = NULL;
500	0	xsd_QName *                         type_attr = NULL;
501
502	0	char *                              prefix = NULL;
503	0	int                                 prefix_created;
504	0	int                                 define_prefix = 0;
505	0	int                                 save_options = options;
506
507	0	GlobusFuncName(wssg_ServiceGroupRPType_serialize);
508	0	GlobusSoapMessageDebugEnter();
509
510
511	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
512		{
513		/* serialize wssg_ServiceGroupRPType element */
514	0	result = globus_soap_message_element_ns_set(
515		message_handle,
516		element_qname,
517		element_qname->Namespace,
518		&options);
519	0	if(result != GLOBUS_SUCCESS)
520		{
521	0	result = GlobusSoapMessageErrorSerializeFailed(
522		result, NULL, element_qname);
523	0	goto exit;
524		}
525
526	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
527		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
528		{
529	0	result = globus_soap_message_attribute_ns_set(
530		message_handle,
531		element_qname,
532		"http://www.w3.org/2001/XMLSchema-instance",
533		&options);
534	0	if(result != GLOBUS_SUCCESS)
535		{
536	0	result = GlobusSoapMessageErrorSerializeFailed(
537		result, NULL, element_qname);
538	0	goto exit;
539		}
540		}
541
542	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
543		!globus_soap_message_serialize_is_c14n_subset(message_handle))
544		{
545
546	0	result = globus_soap_message_attribute_ns_set(
547		message_handle,
548		element_qname,
549		wssg_ServiceGroupRPType_qname.Namespace,
550		&options);
551	0	if(result != GLOBUS_SUCCESS)
552		{
553	0	result = GlobusSoapMessageErrorSerializeFailed(
554		result, NULL, element_qname);
555	0	goto exit;
556		}
557		}
558
559	0	result = globus_soap_message_serialize_element(
560		message_handle,
561		element_qname,
562		options,
563		&wssg_ServiceGroupRPType_qname);
564	0	if(result != GLOBUS_SUCCESS)
565		{
566	0	result = GlobusSoapMessageErrorSerializeFailed(
567		result, NULL, element_qname);
568	0	goto exit;
569		}
570
571	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
572		!globus_soap_message_serialize_is_c14n_subset(message_handle))
573		{
574	0	xsd_QName_init(&type_attr);
575
576	0	type_attr->local = globus_libc_strdup("type");
577	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
578		}
579
580
581		/* serialize namespaces */
582	0	result = globus_soap_message_element_ns_add(
583		message_handle,
584		element_qname,
585		element_qname->Namespace,
586		&options);
587	0	if(result != GLOBUS_SUCCESS)
588		{
589	0	result = GlobusSoapMessageErrorSerializeFailed(
590		result, NULL, element_qname);
591	0	goto exit;
592		}
593
594	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
595		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
596		{
597	0	result = globus_soap_message_attribute_ns_add(
598		message_handle,
599		element_qname,
600		"http://www.w3.org/2001/XMLSchema-instance",
601		&options);
602	0	if(result != GLOBUS_SUCCESS)
603		{
604	0	result = GlobusSoapMessageErrorSerializeFailed(
605		result, NULL, element_qname);
606	0	goto exit;
607		}
608		}
609	0	if ((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
610		!globus_soap_message_serialize_is_c14n_subset(message_handle))
611		{
612
613	0	result = globus_soap_message_attribute_ns_add(
614		message_handle,
615		element_qname,
616		wssg_ServiceGroupRPType_qname.Namespace,
617		&options);
618	0	if(result != GLOBUS_SUCCESS)
619		{
620	0	result = GlobusSoapMessageErrorSerializeFailed(
621		result, NULL, element_qname);
622	0	goto exit;
623		}
624		}
625
626		/* serialize attributes */
627
628	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
629		!globus_soap_message_serialize_is_c14n_subset(message_handle))
630		{
631	0	result = globus_soap_message_serialize_QName_attribute(
632		message_handle,
633		type_attr,
634		&wssg_ServiceGroupRPType_qname);
635	0	if(result != GLOBUS_SUCCESS)
636		{
637	0	result = GlobusSoapMessageErrorSerializeFailed(
638		result, NULL, element_qname);
639	0	goto exit;
640		}
641		}
642
643
644		}
645
646	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
647		{
648	0	result = globus_soap_message_serialize_element_begin_close(
649		message_handle, element_qname);
650	0	if(result != GLOBUS_SUCCESS)
651		{
652	0	result = GlobusSoapMessageErrorSerializeFailed(
653		result, NULL, element_qname);
654	0	goto exit;
655		}
656		}
657	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
658
659
660		/* serialize contents of type */
661
662	0	subelement.local = "MembershipContentRule";
663	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ServiceGroup-1.2-draft-01.xsd";
664
665	0	result = wssg_MembershipContentRuleType_array_serialize(
666		&subelement,
667		&instance->MembershipContentRule,
668		message_handle,
669		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
670	0	if(result != GLOBUS_SUCCESS)
671		{
672	0	result = GlobusSoapMessageErrorSerializeFailed(
673		result, NULL, &wssg_MembershipContentRuleType_qname);
674	0	goto exit;
675		}
676
677	0	subelement.local = "Entry";
678	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ServiceGroup-1.2-draft-01.xsd";
679
680	0	result = wssg_EntryType_array_serialize(
681		&subelement,
682		&instance->Entry,
683		message_handle,
684		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
685	0	if(result != GLOBUS_SUCCESS)
686		{
687	0	result = GlobusSoapMessageErrorSerializeFailed(
688		result, NULL, &wssg_EntryType_qname);
689	0	goto exit;
690		}
691
692	0	options = save_options;
693
694	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
695		{
696		/* add end element */
697	0	result = globus_soap_message_serialize_element_end(
698		message_handle,
699		element_qname,
700		options,
701		&wssg_ServiceGroupRPType_qname);
702	0	if(result != GLOBUS_SUCCESS)
703		{
704	0	result = GlobusSoapMessageErrorSerializeFailed(
705		result, NULL, element_qname);
706	0	goto exit;
707		}
708
709	0	globus_soap_message_element_ns_remove(
710		message_handle,
711		element_qname->Namespace,
712		&options);
713
714		/* remove namespace/prefix mappings for these types */
715
716	0	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
717		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
718		{
719	0	globus_soap_message_attribute_ns_remove(
720		message_handle,
721		"http://www.w3.org/2001/XMLSchema-instance",
722		&options);
723		}
724	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
725		!globus_soap_message_serialize_is_c14n_subset(message_handle))
726		{
727	0	globus_soap_message_attribute_ns_remove(
728		message_handle,
729		wssg_ServiceGroupRPType_qname.Namespace,
730		&options);
731		}
732
733		}
734
735		exit:
736	0	if (type_attr)
737		{
738	0	xsd_QName_destroy(type_attr);
739		}
740
741
742	0	if(any_attr_keys)
743		{
744	0	globus_list_free(any_attr_keys);
745		}
746
747	0	GlobusSoapMessageDebugExit();
748	0	return result;
749		}
750
751
752
753		globus_result_t
754		wssg_ServiceGroupRPType_deserialize_contents(
755		const xsd_QName *                   element_qname, /* ignored */
756		wssg_ServiceGroupRPType *                    inst,
757		globus_soap_message_handle_t        message_handle,
758		globus_xsd_element_options_t        options)
759	0	{
760	0	globus_result_t                     result = GLOBUS_SUCCESS;
761	0	GlobusFuncName(wssg_ServiceGroupRPType_deserialize_contents);
762	0	GlobusSoapMessageDebugEnter();
763
764	0	result = wssg_ServiceGroupRPType_deserialize(
765		NULL,
766		inst,
767		message_handle,
768		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
769	0	if(result != GLOBUS_SUCCESS)
770		{
771	0	result = GlobusSoapMessageErrorDeserializeFailed(
772		result, element_qname);
773		goto exit;
774		}
775
776		exit:
777
778	0	GlobusSoapMessageDebugExit();
779	0	return result;
780		}
781
782
783
784		globus_result_t
785		wssg_ServiceGroupRPType_deserialize(
786		const xsd_QName *                   element_qname,
787		wssg_ServiceGroupRPType *                    instance,
788		globus_soap_message_handle_t        message_handle,
789		globus_xsd_element_options_t        options)
790	0	{
791	0	globus_result_t                     result = GLOBUS_SUCCESS;
792	0	xsd_QName                           subelement;
793	0	GlobusFuncName(wssg_ServiceGroupRPType_deserialize);
794	0	GlobusSoapMessageDebugEnter();
795
796
797	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
798		{
799	0	result = globus_soap_message_deserialize_element(
800		message_handle, element_qname);
801	0	if(result != GLOBUS_SUCCESS)
802		{
803	0	result = GlobusSoapMessageErrorDeserializeFailed(
804		result, element_qname);
805	0	goto exit;
806		}
807
808
809	0	result = globus_soap_message_deserialize_element_begin_close(
810		message_handle);
811	0	if(result != GLOBUS_SUCCESS)
812		{
813	0	result = GlobusSoapMessageErrorDeserializeFailed(
814		result, element_qname);
815	0	goto fail_deserialize;
816		}
817		}
818
819	0	subelement.local = "MembershipContentRule";
820	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ServiceGroup-1.2-draft-01.xsd";
821
822	0	result = wssg_MembershipContentRuleType_array_deserialize(
823		&subelement,
824		&instance->MembershipContentRule,
825		message_handle,
826		0);
827	0	if(result != GLOBUS_SUCCESS)
828		{
829	0	result = GlobusSoapMessageErrorDeserializeFailed(
830		result,
831		(&subelement));
832	0	goto MembershipContentRule_destroy_array;
833		}
834
835	0	subelement.local = "Entry";
836	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ServiceGroup-1.2-draft-01.xsd";
837
838	0	result = wssg_EntryType_array_deserialize(
839		&subelement,
840		&instance->Entry,
841		message_handle,
842		0);
843	0	if(result != GLOBUS_SUCCESS)
844		{
845	0	result = GlobusSoapMessageErrorDeserializeFailed(
846		result,
847		(&subelement));
848	0	goto Entry_destroy_array;
849		}
850
851	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
852		{
853	0	result = globus_soap_message_deserialize_element_end(
854		message_handle,
855		element_qname);
856	0	if(result != GLOBUS_SUCCESS)
857		{
858	0	result = GlobusSoapMessageErrorDeserializeFailed(
859		result, element_qname);
860		goto fail_deserialize;
861		}
862		}
863
864	0	goto exit;
865
866		fail_deserialize:
867	0	wssg_EntryType_array_destroy_contents(
868		&instance->Entry);
869
870		Entry_destroy_array:
871	0	wssg_MembershipContentRuleType_array_destroy_contents(
872		&instance->MembershipContentRule);
873
874		MembershipContentRule_destroy_array:
875
876
877		exit:
878
879	0	GlobusSoapMessageDebugExit();
880	0	return result;
881		}
882
883
884
885		globus_result_t
886		wssg_ServiceGroupRPType_deserialize_pointer(
887		const xsd_QName *                   element_qname,
888		wssg_ServiceGroupRPType **                   ip,
889		globus_soap_message_handle_t        message_handle,
890		globus_xsd_element_options_t        options)
891	0	{
892	0	wssg_ServiceGroupRPType * instance = NULL;
893	0	globus_result_t                     result = GLOBUS_SUCCESS;
894	0	xsd_QName                           subelement;
895	0	int                                 found_attrs = 0;
896	0	int                                 empty_element = 0;
897	0	GlobusFuncName(wssg_ServiceGroupRPType_deserialize_pointer);
898	0	GlobusSoapMessageDebugEnter();
899
900	0	*ip = NULL;
901
902	0	result = globus_soap_message_deserialize_element(
903		message_handle, element_qname);
904	0	if(result != GLOBUS_SUCCESS &&
905		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
906		GlobusSoapMessageStatusFailedElementCheck(result) ||
907		GlobusSoapMessageStatusFailedWithTextCheck(result)))
908		{
909	0	result = GLOBUS_SUCCESS;
910	0	goto exit;
911		}
912
913	0	if(result != GLOBUS_SUCCESS)
914		{
915	0	result = GlobusSoapMessageErrorDeserializeFailed(
916		result, element_qname);
917	0	goto exit;
918		}
919
920	0	if(globus_soap_message_deserialize_element_is_empty(
921		message_handle))
922		{
923	0	empty_element = 1;
924		}
925
926	0	result = wssg_ServiceGroupRPType_init(&instance);
927	0	if(result != GLOBUS_SUCCESS)
928		{
929	0	result = GlobusSoapMessageErrorDeserializeFailed(
930		result, element_qname);
931	0	goto exit;
932		}
933
934
935	0	if(found_attrs == 0 &&
936		globus_soap_message_deserialize_element_is_nil(message_handle))
937		{
938	0	wssg_ServiceGroupRPType_destroy(instance);
939
940	0	result = globus_soap_message_deserialize_element_end(
941		message_handle,
942		element_qname);
943	0	if(result != GLOBUS_SUCCESS)
944		{
945	0	result = GlobusSoapMessageErrorDeserializeFailed(
946		result, element_qname);
947	0	goto exit;
948		}
949
950	0	*ip = NULL;
951	0	globus_object_free(globus_error_get(result));
952	0	result = GLOBUS_SUCCESS;
953	0	goto exit;
954		}
955
956
957	0	if(empty_element)
958		{
959	0	result = globus_soap_message_deserialize_element_end(
960		message_handle,
961		element_qname);
962	0	if(result != GLOBUS_SUCCESS)
963		{
964	0	result = GlobusSoapMessageErrorDeserializeFailed(
965		result, element_qname);
966	0	goto fail_deserialize;
967		}
968
969	0	*ip = instance;
970	0	goto exit;
971		}
972
973	0	result = globus_soap_message_deserialize_element_begin_close(
974		message_handle);
975	0	if(result != GLOBUS_SUCCESS)
976		{
977	0	result = GlobusSoapMessageErrorDeserializeFailed(
978		result, element_qname);
979	0	goto exit;
980		}
981
982	0	result = wssg_ServiceGroupRPType_deserialize(
983		element_qname,
984		instance,
985		message_handle,
986		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
987
988	0	result = globus_soap_message_deserialize_element_end(
989		message_handle,
990		element_qname);
991	0	if(result != GLOBUS_SUCCESS)
992		{
993	0	result = GlobusSoapMessageErrorDeserializeFailed(
994		result, element_qname);
995	0	goto fail_deserialize;
996		}
997
998	0	*ip = instance;
999
1000	0	goto exit;
1001
1002		fail_deserialize:
1003	0	wssg_EntryType_array_destroy_contents(
1004		&instance->Entry);
1005
1006		Entry_destroy_array:
1007	0	wssg_MembershipContentRuleType_array_destroy_contents(
1008		&instance->MembershipContentRule);
1009
1010		MembershipContentRule_destroy_array:
1011
1012		exit:
1013
1014	0	GlobusSoapMessageDebugExit();
1015	0	return result;
1016		}
1017
1018
1019		globus_result_t
1020		wssg_ServiceGroupRPType_array_init_contents(
1021		wssg_ServiceGroupRPType_array * array)
1022	0	{
1023	0	return globus_xsd_generic_array_init_contents(
1024		(globus_xsd_generic_array_t *) array,
1025		&wssg_ServiceGroupRPType_info);
1026		}
1027		/* wssg_ServiceGroupRPType_array_init_contents() */
1028
1029		globus_result_t
1030		wssg_ServiceGroupRPType_array_init(
1031		wssg_ServiceGroupRPType_array ** arr)
1032	0	{
1033	0	return globus_xsd_generic_array_init(
1034		(globus_xsd_generic_array_t **) arr,
1035		&wssg_ServiceGroupRPType_info);
1036		}
1037		/* wssg_ServiceGroupRPType_array_init() */
1038
1039		void
1040		wssg_ServiceGroupRPType_array_destroy_contents(
1041		wssg_ServiceGroupRPType_array * array)
1042	0	{
1043	0	globus_xsd_generic_array_destroy_contents(
1044		(globus_xsd_generic_array_t *) array);
1045		}
1046		/* wssg_ServiceGroupRPType_array_destroy_contents() */
1047
1048		void
1049		wssg_ServiceGroupRPType_array_destroy(
1050		wssg_ServiceGroupRPType_array * array)
1051	0	{
1052	0	globus_xsd_generic_array_destroy(
1053		(globus_xsd_generic_array_t *) array);
1054		}
1055		/* wssg_ServiceGroupRPType_array_destroy() */
1056
1057		globus_result_t
1058		wssg_ServiceGroupRPType_array_copy(
1059		wssg_ServiceGroupRPType_array ** dest_arr,
1060		const wssg_ServiceGroupRPType_array * src_arr)
1061	0	{
1062	0	return globus_xsd_generic_array_copy(
1063		(globus_xsd_generic_array_t **) dest_arr,
1064		(globus_xsd_generic_array_t *) src_arr);
1065		}
1066		/* wssg_ServiceGroupRPType_array_copy() */
1067
1068		globus_result_t
1069		wssg_ServiceGroupRPType_array_copy_contents(
1070		wssg_ServiceGroupRPType_array * dest_arr,
1071		const wssg_ServiceGroupRPType_array * src_arr)
1072	0	{
1073	0	return globus_xsd_generic_array_copy_contents(
1074		(globus_xsd_generic_array_t *) dest_arr,
1075		(globus_xsd_generic_array_t *) src_arr);
1076		}
1077		/* wssg_ServiceGroupRPType_array_copy_contents() */
1078
1079		wssg_ServiceGroupRPType *
1080		wssg_ServiceGroupRPType_array_push(
1081		wssg_ServiceGroupRPType_array * array)
1082	0	{
1083		/* Some contents initializers don't initialize subelments but to set their
1084		* values to be NULL
1085		*/
1086	0	if (array->type_info == NULL)
1087		{
1088	0	array->type_info = &wssg_ServiceGroupRPType_info;
1089		}
1090
1091	0	return globus_xsd_generic_array_push(
1092		(globus_xsd_generic_array_t *) array);
1093		}
1094		/* wssg_ServiceGroupRPType_array_push() */
1095
1096		void *
1097		wssg_ServiceGroupRPType_array_push_wrapper(
1098		void * array)
1099	0	{
1100	0	return (void *) wssg_ServiceGroupRPType_array_push((wssg_ServiceGroupRPType_array *) array);
1101		}
1102
1103		globus_result_t
1104		wssg_ServiceGroupRPType_array_serialize(
1105		const xsd_QName *                   element_qname,
1106		const wssg_ServiceGroupRPType_array *        array,
1107		globus_soap_message_handle_t        message,
1108		globus_xsd_element_options_t        options)
1109	0	{
1110	0	return globus_xsd_generic_array_serialize(
1111		element_qname,
1112		(const globus_xsd_generic_array_t *) array,
1113		message,
1114		options);
1115		}
1116		/* wssg_ServiceGroupRPType_array_serialize() */
1117
1118		globus_result_t
1119		wssg_ServiceGroupRPType_array_deserialize(
1120		const xsd_QName *                   element_qname,
1121		wssg_ServiceGroupRPType_array * array,
1122		globus_soap_message_handle_t        message,
1123		globus_xsd_element_options_t        options)
1124	0	{
1125		/* Some initializers set the array's contents to NULL */
1126	0	if (array->type_info == NULL)
1127		{
1128	0	array->type_info = &wssg_ServiceGroupRPType_info;
1129		}
1130	0	return globus_xsd_generic_array_deserialize(
1131		element_qname,
1132		(globus_xsd_generic_array_t *) array,
1133		message,
1134		options);