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 "rptest_CreateResourcePropertiesTestType.h"
26
27		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
28		xsd_QName rptest_CreateResourcePropertiesTestType_qname =
29		{
30		RPTEST_CREATERESOURCEPROPERTIESTESTTYPE_NS,
31		RPTEST_CREATERESOURCEPROPERTIESTESTTYPE_LOCAL
32		};
33		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
34
35		globus_result_t
36		rptest_CreateResourcePropertiesTestType_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	40	{
42	40	return rptest_CreateResourcePropertiesTestType_serialize(
43		element_qname,
44		(const rptest_CreateResourcePropertiesTestType *) instance,
45		message_handle, options);
46		}
47
48		globus_result_t
49		rptest_CreateResourcePropertiesTestType_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 rptest_CreateResourcePropertiesTestType_deserialize_pointer(
56		element_qname,
57		(rptest_CreateResourcePropertiesTestType **) ip,
58		message_handle, options);
59		}
60
61		globus_result_t
62		rptest_CreateResourcePropertiesTestType_init_wrapper(void **object)
63	0	{
64	0	return rptest_CreateResourcePropertiesTestType_init(
65		(rptest_CreateResourcePropertiesTestType **) object);
66		}
67
68		void
69		rptest_CreateResourcePropertiesTestType_destroy_wrapper(
70		void *                          object)
71	80	{
72	80	rptest_CreateResourcePropertiesTestType_destroy(
73		(rptest_CreateResourcePropertiesTestType *) object);
74		}
75
76		globus_result_t
77		rptest_CreateResourcePropertiesTestType_copy_wrapper(
78		void **                         dest_obj,
79		const void *                    src_obj)
80	80	{
81	80	return rptest_CreateResourcePropertiesTestType_copy(
82		(rptest_CreateResourcePropertiesTestType **) dest_obj,
83		(rptest_CreateResourcePropertiesTestType *) src_obj);
84		}
85
86		globus_result_t
87		rptest_CreateResourcePropertiesTestType_init_contents_wrapper(void *object)
88	0	{
89	0	return rptest_CreateResourcePropertiesTestType_init_contents(
90		(rptest_CreateResourcePropertiesTestType *) object);
91		}
92
93		void
94		rptest_CreateResourcePropertiesTestType_destroy_contents_wrapper(
95		void *                          object)
96	0	{
97	0	rptest_CreateResourcePropertiesTestType_destroy_contents(
98		(rptest_CreateResourcePropertiesTestType *) object);
99		}
100
101		globus_result_t
102		rptest_CreateResourcePropertiesTestType_copy_contents_wrapper(
103		void *                          dest_obj,
104		const void *                    src_obj)
105	0	{
106	0	return rptest_CreateResourcePropertiesTestType_copy_contents(
107		(rptest_CreateResourcePropertiesTestType *) dest_obj,
108		(const rptest_CreateResourcePropertiesTestType *) src_obj);
109		}
110
111		globus_result_t
112		rptest_CreateResourcePropertiesTestType_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 rptest_CreateResourcePropertiesTestType_serialize_contents(
119		element_qname,
120		(rptest_CreateResourcePropertiesTestType *) instance,
121		message_handle, options);
122		}
123
124		globus_result_t
125		rptest_CreateResourcePropertiesTestType_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(rptest_CreateResourcePropertiesTestType_deserialize_contents_wrapper);
133	0	GlobusSoapMessageDebugEnter();
134
135	0	if(!*instance)
136		{
137	0	result = rptest_CreateResourcePropertiesTestType_init(
138		(rptest_CreateResourcePropertiesTestType **)instance);
139	0	if(result != GLOBUS_SUCCESS)
140		{
141	0	goto error;
142		}
143		}
144
145	0	result = rptest_CreateResourcePropertiesTestType_deserialize_contents(
146		element_qname,
147		*(rptest_CreateResourcePropertiesTestType **)instance,
148		message_handle, options);
149		error:
150	0	GlobusSoapMessageDebugExit();
151	0	return result;
152		}
153
154		globus_result_t
155		rptest_CreateResourcePropertiesTestType_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 rptest_CreateResourcePropertiesTestType_array_serialize(
162		element,
163		(rptest_CreateResourcePropertiesTestType_array *) instance,
164		message, options);
165		}
166
167		globus_result_t
168		rptest_CreateResourcePropertiesTestType_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 = rptest_CreateResourcePropertiesTestType_array_init(
179		(rptest_CreateResourcePropertiesTestType_array **)inst);
180	0	if(result != GLOBUS_SUCCESS)
181		{
182	0	return result;
183		}
184		}
185
186	0	return rptest_CreateResourcePropertiesTestType_array_deserialize(
187		element_qname,
188		*(rptest_CreateResourcePropertiesTestType_array **) inst,
189		message, options);
190		}
191
192		globus_result_t
193		rptest_CreateResourcePropertiesTestType_array_init_wrapper(
194		void **                             arr)
195	0	{
196	0	return rptest_CreateResourcePropertiesTestType_array_init(
197		(rptest_CreateResourcePropertiesTestType_array **) arr);
198		}
199
200		void
201		rptest_CreateResourcePropertiesTestType_array_destroy_wrapper(
202		void *                              arr)
203	0	{
204	0	rptest_CreateResourcePropertiesTestType_array_destroy(
205		(rptest_CreateResourcePropertiesTestType_array *) arr);
206		}
207
208		globus_result_t
209		rptest_CreateResourcePropertiesTestType_array_copy_wrapper(
210		void **                             dest_arr,
211		const void *                        src_arr)
212	0	{
213	0	return rptest_CreateResourcePropertiesTestType_array_copy(
214		(rptest_CreateResourcePropertiesTestType_array **) dest_arr,
215		(const rptest_CreateResourcePropertiesTestType_array *) src_arr);
216		}
217
218		globus_result_t
219		rptest_CreateResourcePropertiesTestType_array_init_contents_wrapper(
220		void *                              arr)
221	0	{
222	0	return rptest_CreateResourcePropertiesTestType_array_init_contents(
223		(rptest_CreateResourcePropertiesTestType_array *) arr);
224		}
225
226		void
227		rptest_CreateResourcePropertiesTestType_array_destroy_contents_wrapper(
228		void *                              arr)
229	0	{
230	0	rptest_CreateResourcePropertiesTestType_array_destroy_contents(
231		(rptest_CreateResourcePropertiesTestType_array *) arr);
232		}
233
234		globus_result_t
235		rptest_CreateResourcePropertiesTestType_array_copy_contents_wrapper(
236		void *                              dest_arr,
237		const void *                        src_arr)
238	0	{
239	0	return rptest_CreateResourcePropertiesTestType_array_copy_contents(
240		(rptest_CreateResourcePropertiesTestType_array *) dest_arr,
241		(const rptest_CreateResourcePropertiesTestType_array *) src_arr);
242		}
243
244		struct globus_xsd_type_info_s rptest_CreateResourcePropertiesTestType_contents_info =
245		{
246		&rptest_CreateResourcePropertiesTestType_qname,
247		rptest_CreateResourcePropertiesTestType_serialize_contents_wrapper,
248		rptest_CreateResourcePropertiesTestType_deserialize_contents_wrapper,
249		rptest_CreateResourcePropertiesTestType_init_wrapper,
250		rptest_CreateResourcePropertiesTestType_destroy_wrapper,
251		rptest_CreateResourcePropertiesTestType_copy_wrapper,
252		rptest_CreateResourcePropertiesTestType_init_contents_wrapper,
253		rptest_CreateResourcePropertiesTestType_destroy_contents_wrapper,
254		rptest_CreateResourcePropertiesTestType_copy_contents_wrapper,
255		sizeof(rptest_CreateResourcePropertiesTestType),
256		NULL,
257		NULL,
258		NULL
259		};
260
261		struct globus_xsd_type_info_s rptest_CreateResourcePropertiesTestType_array_info =
262		{
263		&rptest_CreateResourcePropertiesTestType_qname,
264		rptest_CreateResourcePropertiesTestType_array_serialize_wrapper,
265		rptest_CreateResourcePropertiesTestType_array_deserialize_wrapper,
266		rptest_CreateResourcePropertiesTestType_array_init_wrapper,
267		rptest_CreateResourcePropertiesTestType_array_destroy_wrapper,
268		rptest_CreateResourcePropertiesTestType_array_copy_wrapper,
269		rptest_CreateResourcePropertiesTestType_array_init_contents_wrapper,
270		rptest_CreateResourcePropertiesTestType_array_destroy_contents_wrapper,
271		rptest_CreateResourcePropertiesTestType_array_copy_contents_wrapper,
272		sizeof(rptest_CreateResourcePropertiesTestType),
273		rptest_CreateResourcePropertiesTestType_array_push_wrapper,
274		NULL,
275		NULL
276		};
277
278		struct globus_xsd_type_info_s rptest_CreateResourcePropertiesTestType_info =
279		{
280		&rptest_CreateResourcePropertiesTestType_qname,
281		rptest_CreateResourcePropertiesTestType_serialize_wrapper,
282		rptest_CreateResourcePropertiesTestType_deserialize_pointer_wrapper,
283		rptest_CreateResourcePropertiesTestType_init_wrapper,
284		rptest_CreateResourcePropertiesTestType_destroy_wrapper,
285		rptest_CreateResourcePropertiesTestType_copy_wrapper,
286		rptest_CreateResourcePropertiesTestType_init_contents_wrapper,
287		rptest_CreateResourcePropertiesTestType_destroy_contents_wrapper,
288		rptest_CreateResourcePropertiesTestType_copy_contents_wrapper,
289		sizeof(rptest_CreateResourcePropertiesTestType),
290		NULL,
291		&rptest_CreateResourcePropertiesTestType_contents_info,
292		&rptest_CreateResourcePropertiesTestType_array_info
293		};
294
295		globus_result_t
296		rptest_CreateResourcePropertiesTestType_init_contents(
297		rptest_CreateResourcePropertiesTestType * instance)
298	0	{
299	0	globus_result_t                     result = GLOBUS_SUCCESS;
300	0	GlobusFuncName(rptest_CreateResourcePropertiesTestType_init_contents);
301	0	GlobusSoapMessageDebugEnter();
302
303	0	memset(instance, 0, sizeof(rptest_CreateResourcePropertiesTestType));
304
305	0	GlobusSoapMessageDebugExit();
306	0	return result;
307		}
308
309		globus_result_t
310		rptest_CreateResourcePropertiesTestType_init(
311		rptest_CreateResourcePropertiesTestType ** object)
312	80	{
313	80	rptest_CreateResourcePropertiesTestType * instance;
314	80	globus_result_t                     result = GLOBUS_SUCCESS;
315	80	GlobusFuncName(rptest_CreateResourcePropertiesTestType_init);
316	80	GlobusSoapMessageDebugEnter();
317
318	80	instance = globus_malloc(sizeof(rptest_CreateResourcePropertiesTestType));
319	80	if(!instance)
320		{
321	0	result = GlobusSoapMessageErrorOutOfMemory;
322	0	goto exit;
323		}
324
325	80	memset(instance, 0, sizeof(rptest_CreateResourcePropertiesTestType));
326
327	80	*object = instance;
328
329		exit:
330	80	GlobusSoapMessageDebugExit();
331	80	return result;
332		}
333
334		void
335		rptest_CreateResourcePropertiesTestType_destroy(
336		rptest_CreateResourcePropertiesTestType * instance)
337	120	{
338	120	GlobusFuncName(rptest_CreateResourcePropertiesTestType_destroy);
339	120	GlobusSoapMessageDebugEnter();
340
341	120	if(!instance)
342		{
343	0	goto exit;
344		}
345
346	120	rptest_CreateResourcePropertiesTestType_destroy_contents(instance);
347	120	globus_free(instance);
348
349		exit:
350
351	120	GlobusSoapMessageDebugExit();
352		}
353
354
355		void
356		rptest_CreateResourcePropertiesTestType_destroy_contents(
357		rptest_CreateResourcePropertiesTestType * instance)
358	120	{
359	120	GlobusFuncName(rptest_CreateResourcePropertiesTestType_destroy_contents);
360	120	GlobusSoapMessageDebugEnter();
361
362	120	if(instance)
363		{
364
365
366	120	rptest_ResourcePropertyDefinitionType_array_destroy_contents(&instance->ResourcePropertyDefinition);
367
368		}
369
370	120	GlobusSoapMessageDebugExit();
371		}
372
373
374		globus_result_t
375		rptest_CreateResourcePropertiesTestType_copy(
376		rptest_CreateResourcePropertiesTestType ** dest_obj,
377		const rptest_CreateResourcePropertiesTestType * src_obj)
378	80	{
379	80	globus_result_t                     result = GLOBUS_SUCCESS;
380	80	rptest_CreateResourcePropertiesTestType * instance;
381	80	GlobusFuncName(rptest_CreateResourcePropertiesTestType_copy);
382
383	80	GlobusSoapMessageDebugEnter();
384
385	80	instance = calloc(1, sizeof(rptest_CreateResourcePropertiesTestType));
386	80	if (instance == NULL)
387		{
388	0	GlobusSoapMessageDebugExit();
389	0	return GlobusSoapMessageErrorOutOfMemory;
390		}
391
392	80	result = rptest_CreateResourcePropertiesTestType_copy_contents(instance, src_obj);
393	80	if(result != GLOBUS_SUCCESS)
394		{
395	0	globus_free(instance);
396	0	GlobusSoapMessageDebugExit();
397	0	return GlobusSoapMessageErrorOutOfMemory;
398		}
399
400	80	*dest_obj = instance;
401	80	GlobusSoapMessageDebugExit();
402	80	return result;
403		}
404
405		globus_result_t
406		rptest_CreateResourcePropertiesTestType_copy_contents(
407		rptest_CreateResourcePropertiesTestType * instance,
408		const rptest_CreateResourcePropertiesTestType * src_obj)
409	80	{
410	80	globus_result_t                     result = GLOBUS_SUCCESS;
411	80	GlobusFuncName(rptest_CreateResourcePropertiesTestType_copy_contents);
412
413	80	GlobusSoapMessageDebugEnter();
414
415	80	result = rptest_ResourcePropertyDefinitionType_array_copy_contents(
416		&instance->ResourcePropertyDefinition,
417		&src_obj->ResourcePropertyDefinition);
418	80	if(result != GLOBUS_SUCCESS)
419		{
420	0	result = GlobusSoapMessageErrorCopyFailed(
421		result, NULL, &rptest_ResourcePropertyDefinitionType_qname);
422		goto ResourcePropertyDefinition_destroy_array;
423		}
424
425	80	goto exit;
426
427		fail_deserialize:
428	80	rptest_ResourcePropertyDefinitionType_array_destroy_contents(
429		&instance->ResourcePropertyDefinition);
430
431		ResourcePropertyDefinition_destroy_array:
432
433
434		exit:
435
436	80	GlobusSoapMessageDebugExit();
437	80	return result;
438		}
439
440
441
442		globus_result_t
443		rptest_CreateResourcePropertiesTestType_serialize_contents(
444		const xsd_QName *                   element_qname, /* ignored */
445		const rptest_CreateResourcePropertiesTestType *              inst,
446		globus_soap_message_handle_t        message_handle,
447		globus_xsd_element_options_t        options)
448	0	{
449	0	globus_result_t                     result = GLOBUS_SUCCESS;
450	0	GlobusFuncName(rptest_CreateResourcePropertiesTestType_serialize_contents);
451	0	GlobusSoapMessageDebugEnter();
452
453	0	result = rptest_CreateResourcePropertiesTestType_serialize(
454		NULL,
455		inst,
456		message_handle,
457		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
458	0	if(result != GLOBUS_SUCCESS)
459		{
460	0	result = GlobusSoapMessageErrorSerializeFailed(
461		result, NULL, element_qname);
462		goto exit;
463		}
464
465		exit:
466
467	0	GlobusSoapMessageDebugExit();
468	0	return result;
469		}
470
471
472
473		globus_result_t
474		rptest_CreateResourcePropertiesTestType_serialize(
475		const xsd_QName *                   element_qname,
476		const rptest_CreateResourcePropertiesTestType *              instance,
477		globus_soap_message_handle_t        message_handle,
478		globus_xsd_element_options_t        options)
479	40	{
480	40	globus_result_t                     result = GLOBUS_SUCCESS;
481	40	xsd_QName                           subelement;
482	40	globus_list_t *                     any_attr_keys = NULL;
483	40	globus_list_t *                     any_attr_keys_iterator = NULL;
484	40	xsd_QName *                         type_attr = NULL;
485
486	40	char *                              prefix = NULL;
487	40	int                                 prefix_created;
488	40	int                                 define_prefix = 0;
489	40	int                                 save_options = options;
490
491	40	GlobusFuncName(rptest_CreateResourcePropertiesTestType_serialize);
492	40	GlobusSoapMessageDebugEnter();
493
494
495	40	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
496		{
497		/* serialize rptest_CreateResourcePropertiesTestType element */
498	40	result = globus_soap_message_element_ns_set(
499		message_handle,
500		element_qname,
501		element_qname->Namespace,
502		&options);
503	40	if(result != GLOBUS_SUCCESS)
504		{
505	0	result = GlobusSoapMessageErrorSerializeFailed(
506		result, NULL, element_qname);
507	0	goto exit;
508		}
509
510	40	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
511		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
512		{
513	0	result = globus_soap_message_attribute_ns_set(
514		message_handle,
515		element_qname,
516		"http://www.w3.org/2001/XMLSchema-instance",
517		&options);
518	0	if(result != GLOBUS_SUCCESS)
519		{
520	0	result = GlobusSoapMessageErrorSerializeFailed(
521		result, NULL, element_qname);
522	0	goto exit;
523		}
524		}
525
526	40	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
527		!globus_soap_message_serialize_is_c14n_subset(message_handle))
528		{
529
530	0	result = globus_soap_message_attribute_ns_set(
531		message_handle,
532		element_qname,
533		rptest_CreateResourcePropertiesTestType_qname.Namespace,
534		&options);
535	0	if(result != GLOBUS_SUCCESS)
536		{
537	0	result = GlobusSoapMessageErrorSerializeFailed(
538		result, NULL, element_qname);
539	0	goto exit;
540		}
541		}
542
543	40	result = globus_soap_message_serialize_element(
544		message_handle,
545		element_qname,
546		options,
547		&rptest_CreateResourcePropertiesTestType_qname);
548	40	if(result != GLOBUS_SUCCESS)
549		{
550	0	result = GlobusSoapMessageErrorSerializeFailed(
551		result, NULL, element_qname);
552	0	goto exit;
553		}
554
555	40	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
556		!globus_soap_message_serialize_is_c14n_subset(message_handle))
557		{
558	0	xsd_QName_init(&type_attr);
559
560	0	type_attr->local = globus_libc_strdup("type");
561	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
562		}
563
564
565		/* serialize namespaces */
566	40	result = globus_soap_message_element_ns_add(
567		message_handle,
568		element_qname,
569		element_qname->Namespace,
570		&options);
571	40	if(result != GLOBUS_SUCCESS)
572		{
573	0	result = GlobusSoapMessageErrorSerializeFailed(
574		result, NULL, element_qname);
575	0	goto exit;
576		}
577
578	40	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
579		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
580		{
581	0	result = globus_soap_message_attribute_ns_add(
582		message_handle,
583		element_qname,
584		"http://www.w3.org/2001/XMLSchema-instance",
585		&options);
586	0	if(result != GLOBUS_SUCCESS)
587		{
588	0	result = GlobusSoapMessageErrorSerializeFailed(
589		result, NULL, element_qname);
590	0	goto exit;
591		}
592		}
593	40	if ((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
594		!globus_soap_message_serialize_is_c14n_subset(message_handle))
595		{
596
597	0	result = globus_soap_message_attribute_ns_add(
598		message_handle,
599		element_qname,
600		rptest_CreateResourcePropertiesTestType_qname.Namespace,
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
610		/* serialize attributes */
611
612	40	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
613		!globus_soap_message_serialize_is_c14n_subset(message_handle))
614		{
615	0	result = globus_soap_message_serialize_QName_attribute(
616		message_handle,
617		type_attr,
618		&rptest_CreateResourcePropertiesTestType_qname);
619	0	if(result != GLOBUS_SUCCESS)
620		{
621	0	result = GlobusSoapMessageErrorSerializeFailed(
622		result, NULL, element_qname);
623	0	goto exit;
624		}
625		}
626
627
628		}
629
630	40	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
631		{
632	40	result = globus_soap_message_serialize_element_begin_close(
633		message_handle, element_qname);
634	40	if(result != GLOBUS_SUCCESS)
635		{
636	0	result = GlobusSoapMessageErrorSerializeFailed(
637		result, NULL, element_qname);
638	0	goto exit;
639		}
640		}
641	40	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
642
643
644		/* serialize contents of type */
645
646	40	subelement.local = "ResourcePropertyDefinition";
647	40	subelement.Namespace = "http://www.globus.org/namespaces/2004/10/ResourcePropertiesTest";
648
649	40	result = rptest_ResourcePropertyDefinitionType_array_serialize(
650		&subelement,
651		&instance->ResourcePropertyDefinition,
652		message_handle,
653		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
654	40	if(result != GLOBUS_SUCCESS)
655		{
656	0	result = GlobusSoapMessageErrorSerializeFailed(
657		result, NULL, &rptest_ResourcePropertyDefinitionType_qname);
658	0	goto exit;
659		}
660
661	40	options = save_options;
662
663	40	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
664		{
665		/* add end element */
666	40	result = globus_soap_message_serialize_element_end(
667		message_handle,
668		element_qname,
669		options,
670		&rptest_CreateResourcePropertiesTestType_qname);
671	40	if(result != GLOBUS_SUCCESS)
672		{
673	0	result = GlobusSoapMessageErrorSerializeFailed(
674		result, NULL, element_qname);
675	0	goto exit;
676		}
677
678	40	globus_soap_message_element_ns_remove(
679		message_handle,
680		element_qname->Namespace,
681		&options);
682
683		/* remove namespace/prefix mappings for these types */
684
685	40	if(((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
686		!globus_soap_message_serialize_is_c14n_subset(message_handle)))
687		{
688	0	globus_soap_message_attribute_ns_remove(
689		message_handle,
690		"http://www.w3.org/2001/XMLSchema-instance",
691		&options);
692		}
693	40	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
694		!globus_soap_message_serialize_is_c14n_subset(message_handle))
695		{
696	0	globus_soap_message_attribute_ns_remove(
697		message_handle,
698		rptest_CreateResourcePropertiesTestType_qname.Namespace,
699		&options);
700		}
701
702		}
703
704		exit:
705	40	if (type_attr)
706		{
707	0	xsd_QName_destroy(type_attr);
708		}
709
710
711	40	if(any_attr_keys)
712		{
713	0	globus_list_free(any_attr_keys);
714		}
715
716	40	GlobusSoapMessageDebugExit();
717	40	return result;
718		}
719
720
721
722		globus_result_t
723		rptest_CreateResourcePropertiesTestType_deserialize_contents(
724		const xsd_QName *                   element_qname, /* ignored */
725		rptest_CreateResourcePropertiesTestType *                    inst,
726		globus_soap_message_handle_t        message_handle,
727		globus_xsd_element_options_t        options)
728	0	{
729	0	globus_result_t                     result = GLOBUS_SUCCESS;
730	0	GlobusFuncName(rptest_CreateResourcePropertiesTestType_deserialize_contents);
731	0	GlobusSoapMessageDebugEnter();
732
733	0	result = rptest_CreateResourcePropertiesTestType_deserialize(
734		NULL,
735		inst,
736		message_handle,
737		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
738	0	if(result != GLOBUS_SUCCESS)
739		{
740	0	result = GlobusSoapMessageErrorDeserializeFailed(
741		result, element_qname);
742		goto exit;
743		}
744
745		exit:
746
747	0	GlobusSoapMessageDebugExit();
748	0	return result;
749		}
750
751
752
753		globus_result_t
754		rptest_CreateResourcePropertiesTestType_deserialize(
755		const xsd_QName *                   element_qname,
756		rptest_CreateResourcePropertiesTestType *                    instance,
757		globus_soap_message_handle_t        message_handle,
758		globus_xsd_element_options_t        options)
759	40	{
760	40	globus_result_t                     result = GLOBUS_SUCCESS;
761	40	xsd_QName                           subelement;
762	40	GlobusFuncName(rptest_CreateResourcePropertiesTestType_deserialize);
763	40	GlobusSoapMessageDebugEnter();
764
765
766	40	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
767		{
768	40	result = globus_soap_message_deserialize_element(
769		message_handle, element_qname);
770	40	if(result != GLOBUS_SUCCESS)
771		{
772	0	result = GlobusSoapMessageErrorDeserializeFailed(
773		result, element_qname);
774	0	goto exit;
775		}
776
777
778	40	result = globus_soap_message_deserialize_element_begin_close(
779		message_handle);
780	40	if(result != GLOBUS_SUCCESS)
781		{
782	0	result = GlobusSoapMessageErrorDeserializeFailed(
783		result, element_qname);
784	0	goto fail_deserialize;
785		}
786		}
787
788	40	subelement.local = "ResourcePropertyDefinition";
789	40	subelement.Namespace = "http://www.globus.org/namespaces/2004/10/ResourcePropertiesTest";
790
791	40	result = rptest_ResourcePropertyDefinitionType_array_deserialize(
792		&subelement,
793		&instance->ResourcePropertyDefinition,
794		message_handle,
795		0);
796	40	if(result != GLOBUS_SUCCESS)
797		{
798	0	result = GlobusSoapMessageErrorDeserializeFailed(
799		result,
800		(&subelement));
801	0	goto ResourcePropertyDefinition_destroy_array;
802		}
803
804	40	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
805		{
806	40	result = globus_soap_message_deserialize_element_end(
807		message_handle,
808		element_qname);
809	40	if(result != GLOBUS_SUCCESS)
810		{
811	0	result = GlobusSoapMessageErrorDeserializeFailed(
812		result, element_qname);
813		goto fail_deserialize;
814		}
815		}
816
817	0	goto exit;
818
819		fail_deserialize:
820	0	rptest_ResourcePropertyDefinitionType_array_destroy_contents(
821		&instance->ResourcePropertyDefinition);
822
823		ResourcePropertyDefinition_destroy_array:
824
825
826		exit:
827
828	40	GlobusSoapMessageDebugExit();
829	40	return result;
830		}
831
832
833
834		globus_result_t
835		rptest_CreateResourcePropertiesTestType_deserialize_pointer(
836		const xsd_QName *                   element_qname,
837		rptest_CreateResourcePropertiesTestType **                   ip,
838		globus_soap_message_handle_t        message_handle,
839		globus_xsd_element_options_t        options)
840	0	{
841	0	rptest_CreateResourcePropertiesTestType * instance = NULL;
842	0	globus_result_t                     result = GLOBUS_SUCCESS;
843	0	xsd_QName                           subelement;
844	0	int                                 found_attrs = 0;
845	0	int                                 empty_element = 0;
846	0	GlobusFuncName(rptest_CreateResourcePropertiesTestType_deserialize_pointer);
847	0	GlobusSoapMessageDebugEnter();
848
849	0	*ip = NULL;
850
851	0	result = globus_soap_message_deserialize_element(
852		message_handle, element_qname);
853	0	if(result != GLOBUS_SUCCESS &&
854		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
855		GlobusSoapMessageStatusFailedElementCheck(result) ||
856		GlobusSoapMessageStatusFailedWithTextCheck(result)))
857		{
858	0	result = GLOBUS_SUCCESS;
859	0	goto exit;
860		}
861
862	0	if(result != GLOBUS_SUCCESS)
863		{
864	0	result = GlobusSoapMessageErrorDeserializeFailed(
865		result, element_qname);
866	0	goto exit;
867		}
868
869	0	if(globus_soap_message_deserialize_element_is_empty(
870		message_handle))
871		{
872	0	empty_element = 1;
873		}
874
875	0	result = rptest_CreateResourcePropertiesTestType_init(&instance);
876	0	if(result != GLOBUS_SUCCESS)
877		{
878	0	result = GlobusSoapMessageErrorDeserializeFailed(
879		result, element_qname);
880	0	goto exit;
881		}
882
883
884	0	if(found_attrs == 0 &&
885		globus_soap_message_deserialize_element_is_nil(message_handle))
886		{
887	0	rptest_CreateResourcePropertiesTestType_destroy(instance);
888
889	0	result = globus_soap_message_deserialize_element_end(
890		message_handle,
891		element_qname);
892	0	if(result != GLOBUS_SUCCESS)
893		{
894	0	result = GlobusSoapMessageErrorDeserializeFailed(
895		result, element_qname);
896	0	goto exit;
897		}
898
899	0	*ip = NULL;
900	0	globus_object_free(globus_error_get(result));
901	0	result = GLOBUS_SUCCESS;
902	0	goto exit;
903		}
904
905
906	0	if(empty_element)
907		{
908	0	result = globus_soap_message_deserialize_element_end(
909		message_handle,
910		element_qname);
911	0	if(result != GLOBUS_SUCCESS)
912		{
913	0	result = GlobusSoapMessageErrorDeserializeFailed(
914		result, element_qname);
915	0	goto fail_deserialize;
916		}
917
918	0	*ip = instance;
919	0	goto exit;
920		}
921
922	0	result = globus_soap_message_deserialize_element_begin_close(
923		message_handle);
924	0	if(result != GLOBUS_SUCCESS)
925		{
926	0	result = GlobusSoapMessageErrorDeserializeFailed(
927		result, element_qname);
928	0	goto exit;
929		}
930
931	0	result = rptest_CreateResourcePropertiesTestType_deserialize(
932		element_qname,
933		instance,
934		message_handle,
935		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
936
937	0	result = globus_soap_message_deserialize_element_end(
938		message_handle,
939		element_qname);
940	0	if(result != GLOBUS_SUCCESS)
941		{
942	0	result = GlobusSoapMessageErrorDeserializeFailed(
943		result, element_qname);
944	0	goto fail_deserialize;
945		}
946
947	0	*ip = instance;
948
949	0	goto exit;
950
951		fail_deserialize:
952	0	rptest_ResourcePropertyDefinitionType_array_destroy_contents(
953		&instance->ResourcePropertyDefinition);
954
955		ResourcePropertyDefinition_destroy_array:
956
957		exit:
958
959	0	GlobusSoapMessageDebugExit();
960	0	return result;
961		}
962
963
964		globus_result_t
965		rptest_CreateResourcePropertiesTestType_array_init_contents(
966		rptest_CreateResourcePropertiesTestType_array * array)
967	0	{
968	0	return globus_xsd_generic_array_init_contents(
969		(globus_xsd_generic_array_t *) array,
970		&rptest_CreateResourcePropertiesTestType_info);
971		}
972		/* rptest_CreateResourcePropertiesTestType_array_init_contents() */
973
974		globus_result_t
975		rptest_CreateResourcePropertiesTestType_array_init(
976		rptest_CreateResourcePropertiesTestType_array ** arr)
977	0	{
978	0	return globus_xsd_generic_array_init(
979		(globus_xsd_generic_array_t **) arr,
980		&rptest_CreateResourcePropertiesTestType_info);
981		}
982		/* rptest_CreateResourcePropertiesTestType_array_init() */
983
984		void
985		rptest_CreateResourcePropertiesTestType_array_destroy_contents(
986		rptest_CreateResourcePropertiesTestType_array * array)
987	0	{
988	0	globus_xsd_generic_array_destroy_contents(
989		(globus_xsd_generic_array_t *) array);
990		}
991		/* rptest_CreateResourcePropertiesTestType_array_destroy_contents() */
992
993		void
994		rptest_CreateResourcePropertiesTestType_array_destroy(
995		rptest_CreateResourcePropertiesTestType_array * array)
996	0	{
997	0	globus_xsd_generic_array_destroy(
998		(globus_xsd_generic_array_t *) array);
999		}
1000		/* rptest_CreateResourcePropertiesTestType_array_destroy() */
1001
1002		globus_result_t
1003		rptest_CreateResourcePropertiesTestType_array_copy(
1004		rptest_CreateResourcePropertiesTestType_array ** dest_arr,
1005		const rptest_CreateResourcePropertiesTestType_array * src_arr)
1006	0	{
1007	0	return globus_xsd_generic_array_copy(
1008		(globus_xsd_generic_array_t **) dest_arr,
1009		(globus_xsd_generic_array_t *) src_arr);
1010		}
1011		/* rptest_CreateResourcePropertiesTestType_array_copy() */
1012
1013		globus_result_t
1014		rptest_CreateResourcePropertiesTestType_array_copy_contents(
1015		rptest_CreateResourcePropertiesTestType_array * dest_arr,
1016		const rptest_CreateResourcePropertiesTestType_array * src_arr)
1017	0	{
1018	0	return globus_xsd_generic_array_copy_contents(
1019		(globus_xsd_generic_array_t *) dest_arr,
1020		(globus_xsd_generic_array_t *) src_arr);
1021		}
1022		/* rptest_CreateResourcePropertiesTestType_array_copy_contents() */
1023
1024		rptest_CreateResourcePropertiesTestType *
1025		rptest_CreateResourcePropertiesTestType_array_push(
1026		rptest_CreateResourcePropertiesTestType_array * array)
1027	0	{
1028		/* Some contents initializers don't initialize subelments but to set their
1029		* values to be NULL
1030		*/
1031	0	if (array->type_info == NULL)
1032		{
1033	0	array->type_info = &rptest_CreateResourcePropertiesTestType_info;
1034		}
1035
1036	0	return globus_xsd_generic_array_push(
1037		(globus_xsd_generic_array_t *) array);
1038		}
1039		/* rptest_CreateResourcePropertiesTestType_array_push() */
1040
1041		void *
1042		rptest_CreateResourcePropertiesTestType_array_push_wrapper(
1043		void * array)
1044	0	{
1045	0	return (void *) rptest_CreateResourcePropertiesTestType_array_push((rptest_CreateResourcePropertiesTestType_array *) array);
1046		}
1047
1048		globus_result_t
1049		rptest_CreateResourcePropertiesTestType_array_serialize(
1050		const xsd_QName *                   element_qname,
1051		const rptest_CreateResourcePropertiesTestType_array *        array,
1052		globus_soap_message_handle_t        message,
1053		globus_xsd_element_options_t        options)
1054	0	{
1055	0	return globus_xsd_generic_array_serialize(
1056		element_qname,
1057		(const globus_xsd_generic_array_t *) array,
1058		message,
1059		options);
1060		}
1061		/* rptest_CreateResourcePropertiesTestType_array_serialize() */
1062
1063		globus_result_t
1064		rptest_CreateResourcePropertiesTestType_array_deserialize(
1065		const xsd_QName *                   element_qname,
1066		rptest_CreateResourcePropertiesTestType_array * array,
1067		globus_soap_message_handle_t        message,
1068		globus_xsd_element_options_t        options)
1069	0	{
1070		/* Some initializers set the array's contents to NULL */
1071	0	if (array->type_info == NULL)
1072		{
1073	0	array->type_info = &rptest_CreateResourcePropertiesTestType_info;
1074		}
1075	0	return globus_xsd_generic_array_deserialize(
1076		element_qname,
1077		(globus_xsd_generic_array_t *) array,
1078		message,
1079		options);