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