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