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