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