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