1		/*
2		* Portions of this file Copyright 1999-2005 University of Chicago
3		* Portions of this file Copyright 1999-2005 The University of Southern California.
4		*
5		* This file or a portion of this file is licensed under the
6		* terms of the Globus Toolkit Public License, found at
7		* http://www.globus.org/toolkit/download/license.html.
8		* If you redistribute this file, with or without
9		* modifications, you must include this notice in the file.
10		*/
11
12
13		/*
14		* This file is automatically generated by the Globus WSDLtoC converter
15		*/
16
17		#include "xsd_QName.h"
18		#include "globus_soap_message.h"
19		#include "globus_xsd_type_info.h"
20		#include "CounterRPType.h"
21
22		#ifndef GLOBUS_DONT_DOCUMENT_INTERNAL
23		xsd_QName CounterRPType_qname =
24		{
25		COUNTERRPTYPE_NS,
26		COUNTERRPTYPE_LOCAL
27		};
28		#endif /* GLOBUS_DONT_DOCUMENT_INTERNAL */
29
30		globus_result_t
31		CounterRPType_serialize_wrapper(
32		xsd_QName *                         element_qname,
33		void *                              instance,
34		globus_soap_message_handle_t        message_handle,
35		globus_xsd_element_options_t        options)
36	0	{
37	0	return CounterRPType_serialize(
38		element_qname,
39		(CounterRPType *) instance,
40		message_handle, options);
41		}
42
43		globus_result_t
44		CounterRPType_deserialize_pointer_wrapper(
45		xsd_QName *                         element_qname,
46		void **                             ip,
47		globus_soap_message_handle_t        message_handle,
48		globus_xsd_element_options_t        options)
49	0	{
50	0	return CounterRPType_deserialize_pointer(
51		element_qname,
52		(CounterRPType **) ip,
53		message_handle, options);
54		}
55
56		globus_result_t
57		CounterRPType_init_wrapper(void **object)
58	0	{
59	0	return CounterRPType_init(
60		(CounterRPType **) object);
61		}
62
63		void
64		CounterRPType_destroy_wrapper(
65		void *                          object)
66	0	{
67	0	CounterRPType_destroy(
68		(CounterRPType *) object);
69		}
70
71		globus_result_t
72		CounterRPType_copy_wrapper(
73		void **                         dest_obj,
74		void *                          src_obj)
75	0	{
76	0	return CounterRPType_copy(
77		(CounterRPType **) dest_obj,
78		(CounterRPType *) src_obj);
79		}
80
81		globus_result_t
82		CounterRPType_init_contents_wrapper(void *object)
83	0	{
84	0	return CounterRPType_init_contents(
85		(CounterRPType *) object);
86		}
87
88		void
89		CounterRPType_destroy_contents_wrapper(
90		void *                          object)
91	0	{
92	0	CounterRPType_destroy_contents(
93		(CounterRPType *) object);
94		}
95
96		globus_result_t
97		CounterRPType_copy_contents_wrapper(
98		void *                          dest_obj,
99		void *                          src_obj)
100	0	{
101	0	return CounterRPType_copy_contents(
102		(CounterRPType *) dest_obj,
103		(CounterRPType *) src_obj);
104		}
105
106		globus_result_t
107		CounterRPType_serialize_contents_wrapper(
108		xsd_QName *                         element_qname,
109		void *                              instance,
110		globus_soap_message_handle_t        message_handle,
111		globus_xsd_element_options_t        options)
112	0	{
113	0	return CounterRPType_serialize_contents(
114		element_qname,
115		(CounterRPType *) instance,
116		message_handle, options);
117		}
118
119		globus_result_t
120		CounterRPType_deserialize_contents_wrapper(
121		xsd_QName *                         element_qname,
122		void **                             instance,
123		globus_soap_message_handle_t        message_handle,
124		globus_xsd_element_options_t        options)
125	0	{
126	0	globus_result_t                     result;
127	0	GlobusFuncName(CounterRPType_deserialize_contents_wrapper);
128	0	GlobusSoapMessageDebugEnter();
129
130	0	if(!*instance)
131		{
132	0	result = CounterRPType_init(
133		(CounterRPType **)instance);
134	0	if(result != GLOBUS_SUCCESS)
135		{
136	0	goto error;
137		}
138		}
139
140	0	result = CounterRPType_deserialize_contents(
141		element_qname,
142		*(CounterRPType **)instance,
143		message_handle, options);
144		error:
145	0	GlobusSoapMessageDebugExit();
146	0	return result;
147		}
148
149		globus_result_t
150		CounterRPType_array_serialize_wrapper(
151		xsd_QName *                     element,
152		void *                          instance,
153		globus_soap_message_handle_t    message,
154		globus_xsd_element_options_t    options)
155	0	{
156	0	return CounterRPType_array_serialize(
157		element,
158		(CounterRPType_array *) instance,
159		message, options);
160		}
161
162		globus_result_t
163		CounterRPType_array_deserialize_wrapper(
164		xsd_QName *                         element_qname,
165		void **                             inst,
166		globus_soap_message_handle_t        message,
167		globus_xsd_element_options_t        options)
168	0	{
169	0	if(!*inst)
170		{
171	0	globus_result_t                 result;
172
173	0	result = CounterRPType_array_init(
174		(CounterRPType_array **)inst);
175	0	if(result != GLOBUS_SUCCESS)
176		{
177	0	return result;
178		}
179		}
180
181	0	return CounterRPType_array_deserialize(
182		element_qname,
183		*(CounterRPType_array **) inst,
184		message, options);
185		}
186
187		globus_result_t
188		CounterRPType_array_init_wrapper(
189		void **                             arr)
190	0	{
191	0	return CounterRPType_array_init(
192		(CounterRPType_array **) arr);
193		}
194
195		void
196		CounterRPType_array_destroy_wrapper(
197		void *                              arr)
198	0	{
199	0	CounterRPType_array_destroy(
200		(CounterRPType_array *) arr);
201		}
202
203		globus_result_t
204		CounterRPType_array_copy_wrapper(
205		void **                             dest_arr,
206		void *                              src_arr)
207	0	{
208	0	return CounterRPType_array_copy(
209		(CounterRPType_array **) dest_arr,
210		(CounterRPType_array *) src_arr);
211		}
212
213		globus_result_t
214		CounterRPType_array_init_contents_wrapper(
215		void *                              arr)
216	0	{
217	0	return CounterRPType_array_init_contents(
218		(CounterRPType_array *) arr);
219		}
220
221		void
222		CounterRPType_array_destroy_contents_wrapper(
223		void *                              arr)
224	0	{
225	0	CounterRPType_array_destroy_contents(
226		(CounterRPType_array *) arr);
227		}
228
229		globus_result_t
230		CounterRPType_array_copy_contents_wrapper(
231		void *                              dest_arr,
232		void *                              src_arr)
233	0	{
234	0	return CounterRPType_array_copy_contents(
235		(CounterRPType_array *) dest_arr,
236		(CounterRPType_array *) src_arr);
237		}
238
239		struct globus_xsd_type_info_s CounterRPType_contents_info =
240		{
241		&CounterRPType_qname,
242		CounterRPType_serialize_contents_wrapper,
243		CounterRPType_deserialize_contents_wrapper,
244		CounterRPType_init_wrapper,
245		CounterRPType_destroy_wrapper,
246		CounterRPType_copy_wrapper,
247		CounterRPType_init_contents_wrapper,
248		CounterRPType_destroy_contents_wrapper,
249		CounterRPType_copy_contents_wrapper,
250		sizeof(CounterRPType),
251		NULL,
252		NULL,
253		NULL
254		};
255
256		struct globus_xsd_type_info_s CounterRPType_array_info =
257		{
258		&CounterRPType_qname,
259		CounterRPType_array_serialize_wrapper,
260		CounterRPType_array_deserialize_wrapper,
261		CounterRPType_array_init_wrapper,
262		CounterRPType_array_destroy_wrapper,
263		CounterRPType_array_copy_wrapper,
264		CounterRPType_array_init_contents_wrapper,
265		CounterRPType_array_destroy_contents_wrapper,
266		CounterRPType_array_copy_contents_wrapper,
267		sizeof(CounterRPType),
268		CounterRPType_array_push_wrapper,
269		NULL,
270		NULL
271		};
272
273		struct globus_xsd_type_info_s CounterRPType_info =
274		{
275		&CounterRPType_qname,
276		CounterRPType_serialize_wrapper,
277		CounterRPType_deserialize_pointer_wrapper,
278		CounterRPType_init_wrapper,
279		CounterRPType_destroy_wrapper,
280		CounterRPType_copy_wrapper,
281		CounterRPType_init_contents_wrapper,
282		CounterRPType_destroy_contents_wrapper,
283		CounterRPType_copy_contents_wrapper,
284		sizeof(CounterRPType),
285		NULL,
286		&CounterRPType_contents_info,
287		&CounterRPType_array_info
288		};
289
290		globus_result_t
291		CounterRPType_init_contents(
292		CounterRPType * instance)
293	0	{
294	0	globus_result_t                     result = GLOBUS_SUCCESS;
295	0	GlobusFuncName(CounterRPType_init_contents);
296	0	GlobusSoapMessageDebugEnter();
297
298	0	memset(instance, 0, sizeof(CounterRPType));
299
300	0	GlobusSoapMessageDebugExit();
301	0	return result;
302		}
303
304		globus_result_t
305		CounterRPType_init(
306		CounterRPType ** object)
307	0	{
308	0	CounterRPType * instance;
309	0	globus_result_t                     result = GLOBUS_SUCCESS;
310	0	GlobusFuncName(CounterRPType_init);
311	0	GlobusSoapMessageDebugEnter();
312
313	0	instance = globus_malloc(sizeof(CounterRPType));
314	0	if(!instance)
315		{
316	0	result = GlobusSoapMessageErrorOutOfMemory;
317	0	goto exit;
318		}
319
320	0	memset(instance, 0, sizeof(CounterRPType));
321
322	0	*object = instance;
323
324		exit:
325	0	GlobusSoapMessageDebugExit();
326	0	return result;
327		}
328
329		void
330		CounterRPType_destroy(
331		CounterRPType * instance)
332	0	{
333	0	GlobusFuncName(CounterRPType_destroy);
334	0	GlobusSoapMessageDebugEnter();
335
336	0	if(!instance)
337		{
338	0	goto exit;
339		}
340
341	0	CounterRPType_destroy_contents(instance);
342	0	globus_free(instance);
343
344		exit:
345
346	0	GlobusSoapMessageDebugExit();
347		}
348
349		void
350		CounterRPType_destroy_contents(
351		CounterRPType * instance)
352	0	{
353	0	GlobusFuncName(CounterRPType_destroy_contents);
354	0	GlobusSoapMessageDebugEnter();
355
356	0	if(instance)
357		{
358
359
360	0	xsd_int_destroy_contents(
361		&instance->Value);
362
363	0	wsnt_TopicExpressionType_array_destroy_contents(&instance->Topic);
364
365	0	xsd_anyURI_array_destroy_contents(&instance->TopicExpressionDialects);
366
367	0	xsd_dateTime_destroy_contents(
368		&instance->TerminationTime);
369
370	0	xsd_dateTime_destroy_contents(
371		&instance->CurrentTime);
372
373	0	xsd_boolean_destroy_contents(
374		&instance->FixedTopicSet);
375
376		}
377
378	0	GlobusSoapMessageDebugExit();
379		}
380
381		globus_result_t
382		CounterRPType_copy(
383		CounterRPType ** dest_obj,
384		const CounterRPType * src_obj)
385	0	{
386	0	globus_result_t                     result = GLOBUS_SUCCESS;
387	0	CounterRPType * instance;
388	0	GlobusFuncName(CounterRPType_copy);
389
390	0	GlobusSoapMessageDebugEnter();
391
392	0	instance = malloc(sizeof(CounterRPType));
393	0	if (instance == NULL)
394		{
395	0	GlobusSoapMessageDebugExit();
396	0	return GlobusSoapMessageErrorOutOfMemory;
397		}
398
399	0	result = CounterRPType_copy_contents(instance, src_obj);
400	0	if(result != GLOBUS_SUCCESS)
401		{
402	0	globus_free(instance);
403	0	GlobusSoapMessageDebugExit();
404	0	return GlobusSoapMessageErrorOutOfMemory;
405		}
406
407	0	*dest_obj = instance;
408	0	GlobusSoapMessageDebugExit();
409	0	return result;
410		}
411
412		globus_result_t
413		CounterRPType_copy_contents(
414		CounterRPType * instance,
415		const CounterRPType * src_obj)
416	0	{
417	0	globus_result_t                     result = GLOBUS_SUCCESS;
418	0	GlobusFuncName(CounterRPType_copy_contents);
419
420	0	GlobusSoapMessageDebugEnter();
421
422
423	0	result = xsd_int_copy_contents(
424		&instance->Value,
425		&src_obj->Value);
426	0	if(result != GLOBUS_SUCCESS)
427		{
428	0	result = GlobusSoapMessageErrorCopyFailed(
429		result, NULL, &xsd_int_qname);
430	0	goto Value_destroy;
431		}
432
433	0	result = wsnt_TopicExpressionType_array_copy_contents(
434		&instance->Topic,
435		&src_obj->Topic);
436	0	if(result != GLOBUS_SUCCESS)
437		{
438	0	result = GlobusSoapMessageErrorCopyFailed(
439		result, NULL, &wsnt_TopicExpressionType_qname);
440	0	goto Topic_destroy_array;
441		}
442
443	0	result = xsd_anyURI_array_copy_contents(
444		&instance->TopicExpressionDialects,
445		&src_obj->TopicExpressionDialects);
446	0	if(result != GLOBUS_SUCCESS)
447		{
448	0	result = GlobusSoapMessageErrorCopyFailed(
449		result, NULL, &xsd_anyURI_qname);
450	0	goto TopicExpressionDialects_destroy_array;
451		}
452
453	0	result = xsd_dateTime_copy_contents(
454		&instance->TerminationTime,
455		&src_obj->TerminationTime);
456	0	if(result != GLOBUS_SUCCESS)
457		{
458	0	result = GlobusSoapMessageErrorCopyFailed(
459		result, NULL, &xsd_dateTime_qname);
460	0	goto TerminationTime_destroy;
461		}
462
463	0	result = xsd_dateTime_copy_contents(
464		&instance->CurrentTime,
465		&src_obj->CurrentTime);
466	0	if(result != GLOBUS_SUCCESS)
467		{
468	0	result = GlobusSoapMessageErrorCopyFailed(
469		result, NULL, &xsd_dateTime_qname);
470	0	goto CurrentTime_destroy;
471		}
472
473	0	result = xsd_boolean_copy_contents(
474		&instance->FixedTopicSet,
475		&src_obj->FixedTopicSet);
476	0	if(result != GLOBUS_SUCCESS)
477		{
478	0	result = GlobusSoapMessageErrorCopyFailed(
479		result, NULL, &xsd_boolean_qname);
480		goto FixedTopicSet_destroy;
481		}
482
483	0	goto exit;
484
485		fail_deserialize:
486	0	xsd_boolean_destroy_contents(
487		&instance->FixedTopicSet);
488
489		FixedTopicSet_destroy:
490	0	xsd_dateTime_destroy_contents(
491		&instance->CurrentTime);
492
493		CurrentTime_destroy:
494	0	xsd_dateTime_destroy_contents(
495		&instance->TerminationTime);
496
497		TerminationTime_destroy:
498	0	xsd_anyURI_array_destroy_contents(
499		&instance->TopicExpressionDialects);
500
501		TopicExpressionDialects_destroy_array:
502	0	wsnt_TopicExpressionType_array_destroy_contents(
503		&instance->Topic);
504
505		Topic_destroy_array:
506	0	xsd_int_destroy_contents(
507		&instance->Value);
508
509		Value_destroy:
510
511
512		exit:
513
514	0	GlobusSoapMessageDebugExit();
515	0	return result;
516		}
517
518
519
520		globus_result_t
521		CounterRPType_serialize_contents(
522		xsd_QName *                         element_qname, /* ignored */
523		CounterRPType * inst,
524		globus_soap_message_handle_t        message_handle,
525		globus_xsd_element_options_t        options)
526	0	{
527	0	globus_result_t                     result = GLOBUS_SUCCESS;
528	0	GlobusFuncName(CounterRPType_serialize_contents);
529	0	GlobusSoapMessageDebugEnter();
530
531	0	result = CounterRPType_serialize(
532		NULL,
533		inst,
534		message_handle,
535		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
536	0	if(result != GLOBUS_SUCCESS)
537		{
538	0	result = GlobusSoapMessageErrorSerializeFailed(
539		result, NULL, element_qname);
540		goto exit;
541		}
542
543		exit:
544
545	0	GlobusSoapMessageDebugExit();
546	0	return result;
547		}
548
549
550
551		globus_result_t
552		CounterRPType_serialize(
553		xsd_QName *                         element_qname,
554		CounterRPType * instance,
555		globus_soap_message_handle_t        message_handle,
556		globus_xsd_element_options_t        options)
557	0	{
558	0	globus_result_t                     result = GLOBUS_SUCCESS;
559	0	xsd_QName                           subelement;
560	0	globus_list_t *                     any_attr_keys = NULL;
561	0	globus_list_t *                     any_attr_keys_iterator = NULL;
562	0	xsd_QName *                         type_attr = NULL;
563	0	char *                              prefix = NULL;
564	0	int                                 prefix_created;
565	0	int                                 define_prefix = 0;
566	0	int                                 save_options = options;
567
568	0	GlobusFuncName(CounterRPType_serialize);
569	0	GlobusSoapMessageDebugEnter();
570
571
572	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
573		{
574		/* serialize CounterRPType element */
575
576	0	result = globus_soap_message_invoke_ns_callouts(
577		message_handle,
578		element_qname,
579		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_SET,
580		&options);
581	0	if(result != GLOBUS_SUCCESS)
582		{
583	0	result = GlobusSoapMessageErrorSerializeFailed(
584		result, NULL, element_qname);
585	0	goto exit;
586		}
587
588	0	result = globus_soap_message_element_ns_set(
589		message_handle,
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_set(
603		message_handle,
604		"http://www.w3.org/2001/XMLSchema-instance",
605		&options);
606	0	if(result != GLOBUS_SUCCESS)
607		{
608	0	result = GlobusSoapMessageErrorSerializeFailed(
609		result, NULL, element_qname);
610	0	goto exit;
611		}
612
613	0	result = globus_soap_message_attribute_ns_set(
614		message_handle,
615		CounterRPType_qname.Namespace,
616		&options);
617	0	if(result != GLOBUS_SUCCESS)
618		{
619	0	result = GlobusSoapMessageErrorSerializeFailed(
620		result, NULL, element_qname);
621	0	goto exit;
622		}
623		}
624
625	0	result = globus_soap_message_invoke_callouts(
626		message_handle,
627		element_qname,
628		GLOBUS_SOAP_MESSAGE_CALLOUT_BEGIN);
629	0	if(result != GLOBUS_SUCCESS)
630		{
631	0	result = GlobusSoapMessageErrorSerializeFailed(
632		result, NULL, element_qname);
633	0	goto exit;
634		}
635
636	0	result = globus_soap_message_serialize_element(
637		message_handle,
638		element_qname,
639		options,
640		&CounterRPType_qname);
641	0	if(result != GLOBUS_SUCCESS)
642		{
643	0	result = GlobusSoapMessageErrorSerializeFailed(
644		result, NULL, element_qname);
645	0	goto exit;
646		}
647
648	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
649		!globus_soap_message_serialize_is_c14n_subset(message_handle))
650		{
651	0	xsd_QName_init(&type_attr);
652
653	0	type_attr->local = globus_libc_strdup("type");
654	0	type_attr->Namespace = globus_libc_strdup(XSI_NS);
655		}
656
657		/* serialize namespaces */
658
659	0	result = globus_soap_message_invoke_ns_callouts(
660		message_handle,
661		element_qname,
662		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_ADD,
663		&options);
664	0	if(result != GLOBUS_SUCCESS)
665		{
666	0	result = GlobusSoapMessageErrorSerializeFailed(
667		result, NULL, element_qname);
668	0	goto exit;
669		}
670
671	0	result = globus_soap_message_element_ns_add(
672		message_handle,
673		element_qname->Namespace,
674		&options);
675	0	if(result != GLOBUS_SUCCESS)
676		{
677	0	result = GlobusSoapMessageErrorSerializeFailed(
678		result, NULL, element_qname);
679	0	goto exit;
680		}
681
682	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
683		!globus_soap_message_serialize_is_c14n_subset(message_handle))
684		{
685	0	result = globus_soap_message_attribute_ns_add(
686		message_handle,
687		"http://www.w3.org/2001/XMLSchema-instance",
688		&options);
689	0	if(result != GLOBUS_SUCCESS)
690		{
691	0	result = GlobusSoapMessageErrorSerializeFailed(
692		result, NULL, element_qname);
693	0	goto exit;
694		}
695
696	0	result = globus_soap_message_attribute_ns_add(
697		message_handle,
698		CounterRPType_qname.Namespace,
699		&options);
700	0	if(result != GLOBUS_SUCCESS)
701		{
702	0	result = GlobusSoapMessageErrorSerializeFailed(
703		result, NULL, element_qname);
704	0	goto exit;
705		}
706		}
707
708		/* serialize attributes */
709
710	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
711		!globus_soap_message_serialize_is_c14n_subset(message_handle))
712		{
713	0	result = globus_soap_message_serialize_QName_attribute(
714		message_handle,
715		type_attr,
716		&CounterRPType_qname);
717	0	if(result != GLOBUS_SUCCESS)
718		{
719	0	result = GlobusSoapMessageErrorSerializeFailed(
720		result, NULL, element_qname);
721	0	goto exit;
722		}
723		}
724
725
726	0	result = globus_soap_message_invoke_callouts(
727		message_handle,
728		element_qname,
729		GLOBUS_SOAP_MESSAGE_CALLOUT_ATTR);
730	0	if(result != GLOBUS_SUCCESS)
731		{
732	0	result = GlobusSoapMessageErrorSerializeFailed(
733		result, NULL, element_qname);
734	0	goto exit;
735		}
736		}
737
738	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
739		{
740	0	result = globus_soap_message_serialize_element_begin_close(
741		message_handle);
742	0	if(result != GLOBUS_SUCCESS)
743		{
744	0	result = GlobusSoapMessageErrorSerializeFailed(
745		result, NULL, element_qname);
746	0	goto exit;
747		}
748		}
749	0	options &= ~GLOBUS_XSD_ELEMENT_CONTENTS_ONLY;
750
751		/* serialize contents of type */
752
753	0	subelement.local = "Value";
754	0	subelement.Namespace = "http://counter.com";
755
756	0	result = xsd_int_serialize(
757		&subelement,
758		&instance->Value,
759		message_handle,
760		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
761	0	if(result != GLOBUS_SUCCESS)
762		{
763	0	result = GlobusSoapMessageErrorSerializeFailed(
764		result, NULL, &xsd_int_qname);
765	0	goto exit;
766		}
767
768	0	subelement.local = "Topic";
769	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
770
771	0	result = GlobusXSDArrayCheckLowerBounds(
772		1,
773		instance->Topic.length,
774		"Topic");
775	0	if(result != GLOBUS_SUCCESS)
776		{
777	0	result = GlobusSoapMessageErrorSerializeFailed(
778		result, NULL, &wsnt_TopicExpressionType_qname);
779	0	goto exit;
780		}
781
782	0	result = wsnt_TopicExpressionType_array_serialize(
783		&subelement,
784		&instance->Topic,
785		message_handle,
786		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
787	0	if(result != GLOBUS_SUCCESS)
788		{
789	0	result = GlobusSoapMessageErrorSerializeFailed(
790		result, NULL, &wsnt_TopicExpressionType_qname);
791	0	goto exit;
792		}
793
794	0	subelement.local = "TopicExpressionDialects";
795	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
796
797	0	result = GlobusXSDArrayCheckLowerBounds(
798		1,
799		instance->TopicExpressionDialects.length,
800		"TopicExpressionDialects");
801	0	if(result != GLOBUS_SUCCESS)
802		{
803	0	result = GlobusSoapMessageErrorSerializeFailed(
804		result, NULL, &xsd_anyURI_qname);
805	0	goto exit;
806		}
807
808	0	result = xsd_anyURI_array_serialize(
809		&subelement,
810		&instance->TopicExpressionDialects,
811		message_handle,
812		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
813	0	if(result != GLOBUS_SUCCESS)
814		{
815	0	result = GlobusSoapMessageErrorSerializeFailed(
816		result, NULL, &xsd_anyURI_qname);
817	0	goto exit;
818		}
819
820	0	subelement.local = "TerminationTime";
821	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
822
823	0	result = xsd_dateTime_serialize(
824		&subelement,
825		&instance->TerminationTime,
826		message_handle,
827		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
828	0	if(result != GLOBUS_SUCCESS)
829		{
830	0	result = GlobusSoapMessageErrorSerializeFailed(
831		result, NULL, &xsd_dateTime_qname);
832	0	goto exit;
833		}
834
835	0	subelement.local = "CurrentTime";
836	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
837
838	0	result = xsd_dateTime_serialize(
839		&subelement,
840		&instance->CurrentTime,
841		message_handle,
842		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
843	0	if(result != GLOBUS_SUCCESS)
844		{
845	0	result = GlobusSoapMessageErrorSerializeFailed(
846		result, NULL, &xsd_dateTime_qname);
847	0	goto exit;
848		}
849
850	0	subelement.local = "FixedTopicSet";
851	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
852
853	0	result = xsd_boolean_serialize(
854		&subelement,
855		&instance->FixedTopicSet,
856		message_handle,
857		options & (~GLOBUS_XSD_ELEMENT_SET_DEFAULT_NS));
858	0	if(result != GLOBUS_SUCCESS)
859		{
860	0	result = GlobusSoapMessageErrorSerializeFailed(
861		result, NULL, &xsd_boolean_qname);
862	0	goto exit;
863		}
864
865	0	options = save_options;
866
867	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
868		{
869		/* add end element */
870	0	result = globus_soap_message_serialize_element_end(
871		message_handle,
872		element_qname,
873		options,
874		&CounterRPType_qname);
875	0	if(result != GLOBUS_SUCCESS)
876		{
877	0	result = GlobusSoapMessageErrorSerializeFailed(
878		result, NULL, element_qname);
879	0	goto exit;
880		}
881
882	0	globus_soap_message_element_ns_remove(
883		message_handle,
884		element_qname->Namespace,
885		&options);
886
887		/* remove namespace/prefix mappings for these types */
888
889	0	if((options & GLOBUS_XSD_ELEMENT_TYPE_ATTR) &&
890		!globus_soap_message_serialize_is_c14n_subset(message_handle))
891		{
892	0	globus_soap_message_attribute_ns_remove(
893		message_handle,
894		"http://www.w3.org/2001/XMLSchema-instance",
895		&options);
896
897	0	globus_soap_message_attribute_ns_remove(
898		message_handle,
899		CounterRPType_qname.Namespace,
900		&options);
901		}
902
903	0	result = globus_soap_message_invoke_ns_callouts(
904		message_handle,
905		element_qname,
906		GLOBUS_SOAP_MESSAGE_CALLOUT_NS_REMOVE,
907		&options);
908	0	if(result != GLOBUS_SUCCESS)
909		{
910	0	result  = GlobusSoapMessageErrorSerializeFailed(
911		result, NULL, element_qname);
912	0	goto exit;
913		}
914
915	0	result = globus_soap_message_invoke_callouts(
916		message_handle,
917		element_qname,
918		GLOBUS_SOAP_MESSAGE_CALLOUT_END);
919	0	if(result != GLOBUS_SUCCESS)
920		{
921	0	result = GlobusSoapMessageErrorSerializeFailed(
922		result, NULL, element_qname);
923		goto exit;
924		}
925		}
926
927		exit:
928	0	if (type_attr)
929		{
930	0	xsd_QName_destroy(type_attr);
931		}
932
933	0	if(any_attr_keys)
934		{
935	0	globus_list_free(any_attr_keys);
936		}
937
938	0	GlobusSoapMessageDebugExit();
939	0	return result;
940		}
941
942
943
944		globus_result_t
945		CounterRPType_deserialize_contents(
946		xsd_QName *                         element_qname, /* ignored */
947		CounterRPType * inst,
948		globus_soap_message_handle_t        message_handle,
949		globus_xsd_element_options_t        options)
950	0	{
951	0	globus_result_t                     result = GLOBUS_SUCCESS;
952	0	GlobusFuncName(CounterRPType_deserialize_contents);
953	0	GlobusSoapMessageDebugEnter();
954
955	0	result = CounterRPType_deserialize(
956		NULL,
957		inst,
958		message_handle,
959		options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
960	0	if(result != GLOBUS_SUCCESS)
961		{
962	0	result = GlobusSoapMessageErrorDeserializeFailed(
963		result, element_qname);
964		goto exit;
965		}
966
967		exit:
968
969	0	GlobusSoapMessageDebugExit();
970	0	return result;
971		}
972
973
974
975		globus_result_t
976		CounterRPType_deserialize(
977		xsd_QName *                         element_qname,
978		CounterRPType * instance,
979		globus_soap_message_handle_t        message_handle,
980		globus_xsd_element_options_t        options)
981	0	{
982	0	globus_result_t                     result = GLOBUS_SUCCESS;
983	0	xsd_QName                           subelement;
984	0	GlobusFuncName(CounterRPType_deserialize);
985	0	GlobusSoapMessageDebugEnter();
986
987
988	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
989		{
990	0	result = globus_soap_message_deserialize_element(
991		message_handle, element_qname);
992	0	if(result != GLOBUS_SUCCESS)
993		{
994	0	result = GlobusSoapMessageErrorDeserializeFailed(
995		result, element_qname);
996	0	goto exit;
997		}
998
999
1000	0	result = globus_soap_message_deserialize_element_begin_close(
1001		message_handle);
1002	0	if(result != GLOBUS_SUCCESS)
1003		{
1004	0	result = GlobusSoapMessageErrorDeserializeFailed(
1005		result, element_qname);
1006	0	goto fail_deserialize;
1007		}
1008		}
1009
1010	0	subelement.local = "Value";
1011	0	subelement.Namespace = "http://counter.com";
1012
1013	0	result = xsd_int_deserialize(
1014		&subelement,
1015		&instance->Value,
1016		message_handle,
1017		0);
1018	0	if(result != GLOBUS_SUCCESS)
1019		{
1020	0	result = GlobusSoapMessageErrorDeserializeFailed(
1021		result,
1022		&xsd_int_qname);
1023	0	goto Value_destroy;
1024		}
1025
1026	0	subelement.local = "Topic";
1027	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
1028
1029	0	result = wsnt_TopicExpressionType_array_deserialize(
1030		&subelement,
1031		&instance->Topic,
1032		message_handle,
1033		0);
1034	0	if(result != GLOBUS_SUCCESS)
1035		{
1036	0	result = GlobusSoapMessageErrorDeserializeFailed(
1037		result,
1038		(&subelement));
1039	0	goto Topic_destroy_array;
1040		}
1041
1042	0	subelement.local = "TopicExpressionDialects";
1043	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
1044
1045	0	result = xsd_anyURI_array_deserialize(
1046		&subelement,
1047		&instance->TopicExpressionDialects,
1048		message_handle,
1049		0);
1050	0	if(result != GLOBUS_SUCCESS)
1051		{
1052	0	result = GlobusSoapMessageErrorDeserializeFailed(
1053		result,
1054		(&subelement));
1055	0	goto TopicExpressionDialects_destroy_array;
1056		}
1057
1058	0	subelement.local = "TerminationTime";
1059	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
1060
1061	0	result = xsd_dateTime_deserialize(
1062		&subelement,
1063		&instance->TerminationTime,
1064		message_handle,
1065		0);
1066	0	if(result != GLOBUS_SUCCESS)
1067		{
1068	0	result = GlobusSoapMessageErrorDeserializeFailed(
1069		result,
1070		&xsd_dateTime_qname);
1071	0	goto TerminationTime_destroy;
1072		}
1073
1074	0	subelement.local = "CurrentTime";
1075	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
1076
1077	0	result = xsd_dateTime_deserialize(
1078		&subelement,
1079		&instance->CurrentTime,
1080		message_handle,
1081		0);
1082	0	if(result != GLOBUS_SUCCESS)
1083		{
1084	0	result = GlobusSoapMessageErrorDeserializeFailed(
1085		result,
1086		&xsd_dateTime_qname);
1087	0	goto CurrentTime_destroy;
1088		}
1089
1090	0	subelement.local = "FixedTopicSet";
1091	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
1092
1093	0	result = xsd_boolean_deserialize(
1094		&subelement,
1095		&instance->FixedTopicSet,
1096		message_handle,
1097		0);
1098	0	if(result != GLOBUS_SUCCESS)
1099		{
1100	0	result = GlobusSoapMessageErrorDeserializeFailed(
1101		result,
1102		&xsd_boolean_qname);
1103	0	goto FixedTopicSet_destroy;
1104		}
1105
1106	0	if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
1107		{
1108	0	result = globus_soap_message_deserialize_element_end(
1109		message_handle,
1110		element_qname);
1111	0	if(result != GLOBUS_SUCCESS)
1112		{
1113	0	result = GlobusSoapMessageErrorDeserializeFailed(
1114		result, element_qname);
1115		goto fail_deserialize;
1116		}
1117		}
1118
1119	0	goto exit;
1120
1121		fail_deserialize:
1122	0	xsd_boolean_destroy_contents(
1123		&instance->FixedTopicSet);
1124
1125		FixedTopicSet_destroy:
1126	0	xsd_dateTime_destroy_contents(
1127		&instance->CurrentTime);
1128
1129		CurrentTime_destroy:
1130	0	xsd_dateTime_destroy_contents(
1131		&instance->TerminationTime);
1132
1133		TerminationTime_destroy:
1134	0	xsd_anyURI_array_destroy_contents(
1135		&instance->TopicExpressionDialects);
1136
1137		TopicExpressionDialects_destroy_array:
1138	0	wsnt_TopicExpressionType_array_destroy_contents(
1139		&instance->Topic);
1140
1141		Topic_destroy_array:
1142	0	xsd_int_destroy_contents(
1143		&instance->Value);
1144
1145		Value_destroy:
1146
1147
1148		exit:
1149
1150	0	GlobusSoapMessageDebugExit();
1151	0	return result;
1152		}
1153
1154
1155
1156		globus_result_t
1157		CounterRPType_deserialize_pointer(
1158		xsd_QName *                         element_qname,
1159		CounterRPType ** ip,
1160		globus_soap_message_handle_t        message_handle,
1161		globus_xsd_element_options_t        options)
1162	0	{
1163	0	CounterRPType * instance = NULL;
1164	0	globus_result_t                     result = GLOBUS_SUCCESS;
1165	0	xsd_QName                           subelement;
1166	0	int                                 found_attrs = 0;
1167	0	int                                 empty_element = 0;
1168	0	GlobusFuncName(CounterRPType_deserialize_pointer);
1169	0	GlobusSoapMessageDebugEnter();
1170
1171	0	*ip = NULL;
1172
1173	0	result = globus_soap_message_deserialize_element(
1174		message_handle, element_qname);
1175	0	if(result != GLOBUS_SUCCESS &&
1176		(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1177		GlobusSoapMessageStatusFailedElementCheck(result) ||
1178		GlobusSoapMessageStatusFailedWithTextCheck(result)))
1179		{
1180	0	*ip = NULL;
1181	0	result = GLOBUS_SUCCESS;
1182	0	goto exit;
1183		}
1184
1185	0	if(result != GLOBUS_SUCCESS)
1186		{
1187	0	result = GlobusSoapMessageErrorDeserializeFailed(
1188		result, element_qname);
1189	0	goto exit;
1190		}
1191
1192	0	if(globus_soap_message_deserialize_element_is_empty(
1193		message_handle))
1194		{
1195	0	empty_element = 1;
1196		}
1197
1198
1199
1200	0	result = CounterRPType_init(&instance);
1201	0	if(result != GLOBUS_SUCCESS)
1202		{
1203	0	result = GlobusSoapMessageErrorDeserializeFailed(
1204		result, element_qname);
1205	0	goto exit;
1206		}
1207
1208
1209	0	if(found_attrs == 0 &&
1210		globus_soap_message_deserialize_element_is_nil(message_handle))
1211		{
1212	0	CounterRPType_destroy(instance);
1213
1214	0	result = globus_soap_message_deserialize_element_end(
1215		message_handle,
1216		element_qname);
1217	0	if(result != GLOBUS_SUCCESS)
1218		{
1219	0	result = GlobusSoapMessageErrorDeserializeFailed(
1220		result, element_qname);
1221	0	goto exit;
1222		}
1223
1224	0	*ip = NULL;
1225	0	globus_object_free(globus_error_get(result));
1226	0	result = GLOBUS_SUCCESS;
1227	0	goto exit;
1228		}
1229
1230
1231	0	if(empty_element)
1232		{
1233	0	result = globus_soap_message_deserialize_element_end(
1234		message_handle,
1235		element_qname);
1236	0	if(result != GLOBUS_SUCCESS)
1237		{
1238	0	result = GlobusSoapMessageErrorDeserializeFailed(
1239		result, element_qname);
1240	0	goto fail_deserialize;
1241		}
1242
1243	0	*ip = instance;
1244	0	goto exit;
1245		}
1246
1247	0	result = globus_soap_message_deserialize_element_begin_close(
1248		message_handle);
1249	0	if(result != GLOBUS_SUCCESS)
1250		{
1251	0	result = GlobusSoapMessageErrorDeserializeFailed(
1252		result, element_qname);
1253	0	goto exit;
1254		}
1255
1256
1257	0	subelement.local = "Value";
1258	0	subelement.Namespace = "http://counter.com";
1259
1260	0	result = xsd_int_deserialize(
1261		&subelement,
1262		&instance->Value,
1263		message_handle,
1264		0);
1265	0	if(result != GLOBUS_SUCCESS)
1266		{
1267	0	result = GlobusSoapMessageErrorDeserializeFailed(
1268		result,
1269		&xsd_int_qname);
1270	0	goto Value_destroy;
1271		}
1272
1273	0	subelement.local = "Topic";
1274	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
1275
1276	0	result = wsnt_TopicExpressionType_array_deserialize(
1277		&subelement,
1278		&instance->Topic,
1279		message_handle,
1280		0);
1281	0	if(result != GLOBUS_SUCCESS)
1282		{
1283	0	result = GlobusSoapMessageErrorDeserializeFailed(
1284		result,
1285		(&subelement));
1286	0	goto Topic_destroy_array;
1287		}
1288
1289	0	subelement.local = "TopicExpressionDialects";
1290	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
1291
1292	0	result = xsd_anyURI_array_deserialize(
1293		&subelement,
1294		&instance->TopicExpressionDialects,
1295		message_handle,
1296		0);
1297	0	if(result != GLOBUS_SUCCESS)
1298		{
1299	0	result = GlobusSoapMessageErrorDeserializeFailed(
1300		result,
1301		(&subelement));
1302	0	goto TopicExpressionDialects_destroy_array;
1303		}
1304
1305	0	subelement.local = "TerminationTime";
1306	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
1307
1308	0	result = xsd_dateTime_deserialize(
1309		&subelement,
1310		&instance->TerminationTime,
1311		message_handle,
1312		0);
1313	0	if(result != GLOBUS_SUCCESS)
1314		{
1315	0	result = GlobusSoapMessageErrorDeserializeFailed(
1316		result,
1317		&xsd_dateTime_qname);
1318	0	goto TerminationTime_destroy;
1319		}
1320
1321	0	subelement.local = "CurrentTime";
1322	0	subelement.Namespace = "http://docs.oasis-open.org/wsrf/2004/06/wsrf-WS-ResourceLifetime-1.2-draft-01.xsd";
1323
1324	0	result = xsd_dateTime_deserialize(
1325		&subelement,
1326		&instance->CurrentTime,
1327		message_handle,
1328		0);
1329	0	if(result != GLOBUS_SUCCESS)
1330		{
1331	0	result = GlobusSoapMessageErrorDeserializeFailed(
1332		result,
1333		&xsd_dateTime_qname);
1334	0	goto CurrentTime_destroy;
1335		}
1336
1337	0	subelement.local = "FixedTopicSet";
1338	0	subelement.Namespace = "http://docs.oasis-open.org/wsn/2004/06/wsn-WS-BaseNotification-1.2-draft-01.xsd";
1339
1340	0	result = xsd_boolean_deserialize(
1341		&subelement,
1342		&instance->FixedTopicSet,
1343		message_handle,
1344		0);
1345	0	if(result != GLOBUS_SUCCESS)
1346		{
1347	0	result = GlobusSoapMessageErrorDeserializeFailed(
1348		result,
1349		&xsd_boolean_qname);
1350	0	goto FixedTopicSet_destroy;
1351		}
1352
1353
1354	0	result = globus_soap_message_deserialize_element_end(
1355		message_handle,
1356		element_qname);
1357	0	if(result != GLOBUS_SUCCESS)
1358		{
1359	0	result = GlobusSoapMessageErrorDeserializeFailed(
1360		result, element_qname);
1361	0	goto fail_deserialize;
1362		}
1363
1364	0	*ip = instance;
1365
1366	0	goto exit;
1367
1368		fail_deserialize:
1369	0	xsd_boolean_destroy_contents(
1370		&instance->FixedTopicSet);
1371
1372		FixedTopicSet_destroy:
1373	0	xsd_dateTime_destroy_contents(
1374		&instance->CurrentTime);
1375
1376		CurrentTime_destroy:
1377	0	xsd_dateTime_destroy_contents(
1378		&instance->TerminationTime);
1379
1380		TerminationTime_destroy:
1381	0	xsd_anyURI_array_destroy_contents(
1382		&instance->TopicExpressionDialects);
1383
1384		TopicExpressionDialects_destroy_array:
1385	0	wsnt_TopicExpressionType_array_destroy_contents(
1386		&instance->Topic);
1387
1388		Topic_destroy_array:
1389	0	xsd_int_destroy_contents(
1390		&instance->Value);
1391
1392		Value_destroy:
1393
1394		exit:
1395
1396	0	GlobusSoapMessageDebugExit();
1397	0	return result;
1398		}
1399
1400
1401		globus_result_t
1402		CounterRPType_array_init_contents(
1403		CounterRPType_array * array)
1404	0	{
1405	0	GlobusFuncName(CounterRPType_array_init_contents);
1406	0	GlobusSoapMessageDebugEnter();
1407
1408	0	memset(array, 0, sizeof(CounterRPType_array));
1409
1410	0	GlobusSoapMessageDebugExit();
1411	0	return GLOBUS_SUCCESS;
1412		}
1413
1414		globus_result_t
1415		CounterRPType_array_init(
1416		CounterRPType_array ** arr)
1417	0	{
1418	0	CounterRPType_array * array;
1419	0	globus_result_t                     result;
1420	0	GlobusFuncName(CounterRPType_array_init);
1421	0	GlobusSoapMessageDebugEnter();
1422
1423	0	array = (CounterRPType_array *)
1424		globus_malloc(sizeof(CounterRPType_array));
1425	0	if(!array)
1426		{
1427	0	result = GlobusSoapMessageErrorOutOfMemory;
1428	0	goto exit;
1429		}
1430
1431	0	result = CounterRPType_array_init_contents(array);
1432	0	if(result != GLOBUS_SUCCESS)
1433		{
1434	0	globus_free(array);
1435	0	array = NULL;
1436
1437		}
1438
1439	0	*arr = array;
1440
1441		exit:
1442	0	GlobusSoapMessageDebugExit();
1443	0	return result;
1444		}
1445
1446		void
1447		CounterRPType_array_destroy_contents(
1448		CounterRPType_array * array)
1449	0	{
1450	0	int                                 i = 0;
1451	0	GlobusFuncName(CounterRPType_array_destroy_contents);
1452	0	GlobusSoapMessageDebugEnter();
1453
1454	0	for(; i < array->length; ++i)
1455		{
1456	0	CounterRPType_destroy_contents(&array->elements[i]);
1457		}
1458
1459	0	if(array->elements)
1460		{
1461	0	globus_free(array->elements);
1462	0	array->elements = NULL;
1463		}
1464	0	array->length = 0;
1465
1466	0	GlobusSoapMessageDebugExit();
1467		}
1468
1469		void
1470		CounterRPType_array_destroy(
1471		CounterRPType_array * array)
1472	0	{
1473	0	GlobusFuncName(CounterRPType_array_destroy);
1474	0	GlobusSoapMessageDebugEnter();
1475
1476	0	CounterRPType_array_destroy_contents(array);
1477	0	globus_free(array);
1478
1479	0	GlobusSoapMessageDebugExit();
1480		}
1481
1482		globus_result_t
1483		CounterRPType_array_copy(
1484		CounterRPType_array ** dest_arr,
1485		const CounterRPType_array * src_arr)
1486	0	{
1487	0	CounterRPType_array * array;
1488	0	globus_result_t                     result;
1489	0	GlobusFuncName(CounterRPType_array_copy);
1490	0	GlobusSoapMessageDebugEnter();
1491
1492	0	array = (CounterRPType_array *) globus_malloc(
1493		sizeof(CounterRPType_array));
1494	0	if(!array)
1495		{
1496	0	result = GlobusSoapMessageErrorOutOfMemory;
1497	0	GlobusSoapMessageDebugExit();
1498	0	return result;
1499		}
1500
1501	0	result = CounterRPType_array_copy_contents(array, src_arr);
1502	0	if(result != GLOBUS_SUCCESS)
1503		{
1504	0	globus_free(array);
1505	0	GlobusSoapMessageDebugExit();
1506	0	return result;
1507		}
1508
1509	0	*dest_arr = array;
1510
1511	0	GlobusSoapMessageDebugExit();
1512	0	return GLOBUS_SUCCESS;
1513		}
1514
1515		globus_result_t
1516		CounterRPType_array_copy_contents(
1517		CounterRPType_array * dest_arr,
1518		const CounterRPType_array * src_arr)
1519	0	{
1520	0	int                                 i;
1521	0	globus_result_t                     result = GLOBUS_SUCCESS;
1522	0	GlobusFuncName(CounterRPType_array_copy_contents);
1523	0	GlobusSoapMessageDebugEnter();
1524
1525	0	dest_arr->length = src_arr->length;
1526	0	if(dest_arr->length > 0)
1527		{
1528	0	dest_arr->elements = (CounterRPType *) malloc(
1529		sizeof(CounterRPType) * dest_arr->length);
1530	0	if(!dest_arr->elements)
1531		{
1532	0	result = GlobusSoapMessageErrorOutOfMemory;
1533	0	GlobusSoapMessageDebugExit();
1534	0	return result;
1535		}
1536		}
1537		else
1538		{
1539	0	dest_arr->elements = NULL;
1540		}
1541
1542	0	for(i = 0; i < dest_arr->length; i++)
1543		{
1544	0	result = CounterRPType_copy_contents(
1545		&dest_arr->elements[i], &src_arr->elements[i]);
1546	0	if(result != GLOBUS_SUCCESS)
1547		{
1548	0	while(i--)
1549		{
1550	0	CounterRPType_destroy_contents(&dest_arr->elements[i]);
1551		}
1552
1553	0	globus_free(dest_arr->elements);
1554	0	dest_arr->elements = NULL;
1555	0	dest_arr->length = 0;
1556	0	break;
1557		}
1558		}
1559
1560	0	GlobusSoapMessageDebugExit();
1561	0	return result;
1562		}
1563
1564		CounterRPType *
1565		CounterRPType_array_push(
1566		CounterRPType_array * array)
1567	0	{
1568	0	GlobusFuncName(CounterRPType_array_push);
1569	0	GlobusSoapMessageDebugEnter();
1570
1571	0	array->elements = realloc(array->elements,
1572		sizeof(CounterRPType) *
1573		(array->length + 1));
1574	0	memset(&array->elements[array->length], 0, sizeof(CounterRPType));
1575	0	array->length++;
1576
1577	0	GlobusSoapMessageDebugExit();
1578	0	return (&array->elements[array->length - 1]);
1579		}
1580
1581		void *
1582		CounterRPType_array_push_wrapper(
1583		void * array)
1584	0	{
1585	0	return (void *) CounterRPType_array_push((CounterRPType_array *) array);
1586		}
1587
1588		globus_result_t
1589		CounterRPType_array_serialize(
1590		xsd_QName *                         element_qname,
1591		CounterRPType_array * array,
1592		globus_soap_message_handle_t        message,
1593		globus_xsd_element_options_t        options)
1594	0	{
1595	0	globus_result_t                     result = GLOBUS_SUCCESS;
1596	0	int                                 i = 0;
1597	0	GlobusFuncName(CounterRPType_array_serialize);
1598	0	GlobusSoapMessageDebugEnter();
1599
1600	0	for(; i < array->length; ++i)
1601		{
1602	0	result = CounterRPType_serialize(
1603		element_qname,
1604		&array->elements[i],
1605		message,
1606		options);
1607	0	if(result != GLOBUS_SUCCESS)
1608		{
1609	0	goto exit;
1610		}
1611		}
1612
1613		exit:
1614
1615	0	GlobusSoapMessageDebugExit();
1616	0	return result;
1617		}
1618
1619		globus_result_t
1620		CounterRPType_array_deserialize(
1621		xsd_QName *                         element_qname,
1622		CounterRPType_array * array,
1623		globus_soap_message_handle_t        message,
1624		globus_xsd_element_options_t        options)
1625	0	{
1626	0	globus_result_t                     result = GLOBUS_SUCCESS;
1627	0	int                                 i = 0;
1628	0	int                                 pre_length;
1629	0	GlobusFuncName(CounterRPType_array_deserialize);
1630	0	GlobusSoapMessageDebugEnter();
1631
1632	0	pre_length = array->length;
1633
1634	0	for(i = 0; i < pre_length; ++i)
1635		{
1636	0	result = CounterRPType_deserialize(
1637		element_qname,
1638		&array->elements[i],
1639		message,
1640		options);
1641	0	if(result != GLOBUS_SUCCESS)
1642		{
1643	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1644		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1645		GlobusSoapMessageStatusFailedWithTextCheck(result))
1646		{
1647	0	result = GLOBUS_SUCCESS;
1648	0	break;
1649		}
1650
1651	0	result = GlobusSoapMessageErrorDeserializeFailed(
1652		result, element_qname);
1653	0	goto exit;
1654		}
1655		}
1656
1657	0	while(result == GLOBUS_SUCCESS)
1658		{
1659	0	CounterRPType                  next;
1660	0	memset(&next, 0, sizeof(CounterRPType));
1661
1662	0	result = CounterRPType_deserialize(
1663		element_qname,
1664		&next,
1665		message,
1666		options);
1667	0	if(result != GLOBUS_SUCCESS)
1668		{
1669	0	if(GlobusSoapMessageStatusFailedElementCheck(result) ||
1670		GlobusSoapMessageStatusElementNotFoundCheck(result) ||
1671		GlobusSoapMessageStatusFailedWithTextCheck(result))
1672		{
1673	0	result = GLOBUS_SUCCESS;
1674	0	break;
1675		}
1676
1677	0	result = GlobusSoapMessageErrorDeserializeFailed(
1678		result, element_qname);
1679	0	goto exit;
1680		}
1681
1682	0	array->elements = realloc(
1683		array->elements,
1684		(array->length + 1) * sizeof(CounterRPType));
1685	0	if(!array->elements)
1686		{
1687	0	result = GlobusSoapMessageErrorOutOfMemory;
1688	0	goto exit;
1689		}
1690	0	array->elements[array->length] = next;
1691	0	array->length++;
1692	0	++i;
1693		}
1694
1695		exit:
1696
1697	0	if(result != GLOBUS_SUCCESS)
1698		{
1699	0	int                             di = 0;
1700	0	for(; di < i; ++di)
1701		{
1702	0	CounterRPType_destroy_contents(
1703		&array->elements[di]);
1704	0	memset(&array->elements[di], 0, sizeof(CounterRPType));
1705		}
1706		}
1707
1708	0	GlobusSoapMessageDebugExit();
1709	0	return result;