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 "globus_soap_message.h"
23		#include "globus_handler.h"
24		#include "globus_xio.h"
25		#include "CounterService_client.h"
26		#include "globus_xsd_type_registry.h"
27		#include "globus_soap_message_fault.h"
28		#include "globus_soap_message_attrs.h"
29		#include "globus_soap_message_markers.h"
30		#include "globus_ws_addressing.h"
31
32		static globus_list_t * CounterService_l_extensions = NULL;
33		static globus_mutex_t CounterService_l_extensions_mutex;
34
35		static
36		int
37		CounterService_l_client_module_activate();
38
39		static
40		int
41		CounterService_l_client_module_deactivate();
42
43		globus_module_descriptor_t
44		CounterService_i_module =
45		{
46		"CounterService",
47		CounterService_l_client_module_activate,
48		CounterService_l_client_module_deactivate
49		};
50
51
52		static
53		void
54		CounterPortType_l_SetTerminationTime_deserialize_fault(
55		globus_soap_message_handle_t handle,
56		const xsd_QName * fault_qname,
57		int * fault_type);
58
59
60		static
61		globus_soap_client_operation_t CounterPortType_l_SetTerminationTime_operation =
62		{
63		{ "http://docs.oasis-open.org/wsrf/rl-2", "SetTerminationTime" } ,
64		&wsrl_SetTerminationTimeType_info,
65
66		{ "http://docs.oasis-open.org/wsrf/rl-2", "SetTerminationTimeResponse" },
67		&wsrl_SetTerminationTimeResponseType_info,
68
69		"http://docs.oasis-open.org/wsrf/rlw-2/ScheduledResourceTermination/SetTerminationTimeRequest",
70
71		"http://docs.oasis-open.org/wsrf/rlw-2/ScheduledResourceTermination/SetTerminationTimeResponse",
72
73
74		CounterPortType_l_SetTerminationTime_deserialize_fault
75
76		};
77
78
79		static
80		void
81		CounterPortType_l_Destroy_deserialize_fault(
82		globus_soap_message_handle_t handle,
83		const xsd_QName * fault_qname,
84		int * fault_type);
85
86
87		static
88		globus_soap_client_operation_t CounterPortType_l_Destroy_operation =
89		{
90		{ "http://docs.oasis-open.org/wsrf/rl-2", "Destroy" } ,
91		&wsrl_DestroyType_info,
92
93		{ "http://docs.oasis-open.org/wsrf/rl-2", "DestroyResponse" },
94		&wsrl_DestroyResponseType_info,
95
96		"http://docs.oasis-open.org/wsrf/rlw-2/ImmediateResourceTermination/DestroyRequest",
97
98		"http://docs.oasis-open.org/wsrf/rlw-2/ImmediateResourceTermination/DestroyResponse",
99
100
101		CounterPortType_l_Destroy_deserialize_fault
102
103		};
104
105
106		static
107		void
108		CounterPortType_l_GetCurrentMessage_deserialize_fault(
109		globus_soap_message_handle_t handle,
110		const xsd_QName * fault_qname,
111		int * fault_type);
112
113
114		static
115		globus_soap_client_operation_t CounterPortType_l_GetCurrentMessage_operation =
116		{
117		{ "http://docs.oasis-open.org/wsn/b-2", "GetCurrentMessage" } ,
118		&wsnt_GetCurrentMessageType_info,
119
120		{ "http://docs.oasis-open.org/wsn/b-2", "GetCurrentMessageResponse" },
121		&wsnt_GetCurrentMessageResponseType_info,
122
123		"http://docs.oasis-open.org/wsn/bw-2/NotificationProducer/GetCurrentMessageRequest",
124
125		"http://docs.oasis-open.org/wsn/bw-2/NotificationProducer/GetCurrentMessageResponse",
126
127
128		CounterPortType_l_GetCurrentMessage_deserialize_fault
129
130		};
131
132
133		static
134		void
135		CounterPortType_l_Subscribe_deserialize_fault(
136		globus_soap_message_handle_t handle,
137		const xsd_QName * fault_qname,
138		int * fault_type);
139
140
141		static
142		globus_soap_client_operation_t CounterPortType_l_Subscribe_operation =
143		{
144		{ "http://docs.oasis-open.org/wsn/b-2", "Subscribe" } ,
145		&wsnt_SubscribeType_info,
146
147		{ "http://docs.oasis-open.org/wsn/b-2", "SubscribeResponse" },
148		&wsnt_SubscribeResponseType_info,
149
150		"http://docs.oasis-open.org/wsn/bw-2/NotificationProducer/SubscribeRequest",
151
152		"http://docs.oasis-open.org/wsn/bw-2/NotificationProducer/SubscribeResponse",
153
154
155		CounterPortType_l_Subscribe_deserialize_fault
156
157		};
158
159
160		static
161		void
162		CounterPortType_l_GetMultipleResourceProperties_deserialize_fault(
163		globus_soap_message_handle_t handle,
164		const xsd_QName * fault_qname,
165		int * fault_type);
166
167
168		static
169		globus_soap_client_operation_t CounterPortType_l_GetMultipleResourceProperties_operation =
170		{
171		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetMultipleResourceProperties" } ,
172		&wsrp_GetMultipleResourcePropertiesType_info,
173
174		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetMultipleResourcePropertiesResponse" },
175		&wsrp_GetMultipleResourcePropertiesResponseType_info,
176
177		"http://docs.oasis-open.org/wsrf/rpw-2/GetMultipleResourceProperties/GetMultipleResourcePropertiesRequest",
178
179		"http://docs.oasis-open.org/wsrf/rpw-2/GetMultipleResourceProperties/GetMultipleResourcePropertiesResponse",
180
181
182		CounterPortType_l_GetMultipleResourceProperties_deserialize_fault
183
184		};
185
186
187		static
188		void
189		CounterPortType_l_QueryResourceProperties_deserialize_fault(
190		globus_soap_message_handle_t handle,
191		const xsd_QName * fault_qname,
192		int * fault_type);
193
194
195		static
196		globus_soap_client_operation_t CounterPortType_l_QueryResourceProperties_operation =
197		{
198		{ "http://docs.oasis-open.org/wsrf/rp-2", "QueryResourceProperties" } ,
199		&wsrp_QueryResourcePropertiesType_info,
200
201		{ "http://docs.oasis-open.org/wsrf/rp-2", "QueryResourcePropertiesResponse" },
202		&wsrp_QueryResourcePropertiesResponseType_info,
203
204		"http://docs.oasis-open.org/wsrf/rpw-2/QueryResourceProperties/QueryResourcePropertiesRequest",
205
206		"http://docs.oasis-open.org/wsrf/rpw-2/QueryResourceProperties/QueryResourcePropertiesResponse",
207
208
209		CounterPortType_l_QueryResourceProperties_deserialize_fault
210
211		};
212
213
214		static
215		void
216		CounterPortType_l_GetResourceProperty_deserialize_fault(
217		globus_soap_message_handle_t handle,
218		const xsd_QName * fault_qname,
219		int * fault_type);
220
221
222		static
223		globus_soap_client_operation_t CounterPortType_l_GetResourceProperty_operation =
224		{
225		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetResourceProperty" } ,
226		&xsd_QName_info,
227
228		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetResourcePropertyResponse" },
229		&wsrp_GetResourcePropertyResponseType_info,
230
231		"http://docs.oasis-open.org/wsrf/rpw-2/GetResourceProperty/GetResourcePropertyRequest",
232
233		"http://docs.oasis-open.org/wsrf/rpw-2/GetResourceProperty/GetResourcePropertyResponse",
234
235
236		CounterPortType_l_GetResourceProperty_deserialize_fault
237
238		};
239
240
241		static
242		void
243		CounterPortType_l_add_deserialize_fault(
244		globus_soap_message_handle_t handle,
245		const xsd_QName * fault_qname,
246		int * fault_type);
247
248
249		static
250		globus_soap_client_operation_t CounterPortType_l_add_operation =
251		{
252		{ "http://counter.com", "add" } ,
253		&xsd_int_info,
254
255		{ "http://counter.com", "addResponse" },
256		&xsd_int_info,
257
258		"http://counter.com/CounterPortType/addRequest",
259
260		"http://counter.com/CounterPortType/addResponse",
261
262
263		CounterPortType_l_add_deserialize_fault
264
265		};
266
267
268		static
269		void
270		CounterPortType_l_createCounter_deserialize_fault(
271		globus_soap_message_handle_t handle,
272		const xsd_QName * fault_qname,
273		int * fault_type);
274
275
276		static
277		globus_soap_client_operation_t CounterPortType_l_createCounter_operation =
278		{
279		{ "http://counter.com", "createCounter" } ,
280		&counter_createCounterType_info,
281
282		{ "http://counter.com", "createCounterResponse" },
283		&counter_createCounterResponseType_info,
284
285		"http://counter.com/CounterPortType/createCounterRequest",
286
287		"http://counter.com/CounterPortType/createCounterResponse",
288
289
290		CounterPortType_l_createCounter_deserialize_fault
291
292		};
293
294
295		static
296		int
297		CounterService_l_client_module_activate()
298	17	{
299	17	int res = 0;
300	17	globus_result_t result = GLOBUS_SUCCESS;
301	17	res = globus_module_activate(GLOBUS_SOAP_MESSAGE_MODULE);
302	17	if(res != GLOBUS_SUCCESS)
303		{
304	0	return res;
305		}
306
307	17	result = CounterService_registry_add_types(GLOBUS_GLOBAL_TYPE_REGISTRY);
308	17	if(result != GLOBUS_SUCCESS)
309		{
310	0	result = GlobusSoapMessageErrorFailedClientInit(
311		result, "CounterService");
312		}
313
314
315	17	globus_mutex_init(&CounterService_l_extensions_mutex, NULL);
316
317	17	return res;
318		}
319
320		static
321		void
322		CounterService_l_extension_destroy(
323		void * sym)
324	17	{
325	17	char * symbol = (char *) sym;
326
327	17	globus_extension_deactivate(symbol);
328	17	globus_free(symbol);
329	17	}
330
331		static
332		int
333		CounterService_l_client_module_deactivate()
334	17	{
335	17	int res = 0;
336
337	17	globus_module_deactivate(GLOBUS_SOAP_MESSAGE_MODULE);
338
339	17	globus_mutex_lock(&CounterService_l_extensions_mutex);
340	17	globus_list_destroy_all(
341		CounterService_l_extensions,
342		CounterService_l_extension_destroy);
343	17	CounterService_l_extensions = NULL;
344	17	globus_mutex_unlock(&CounterService_l_extensions_mutex);
345	17	globus_mutex_destroy(&CounterService_l_extensions_mutex);
346
347	17	return res;
348		}
349
350		/**
351		* Initialize a client handle
352		* @ingroup CounterService_client_handle
353		* Initialize new client handle state for use with operation-related functions.
354		*
355		* @param handle
356		* Pointer to the handle to initialize.
357		* @param attrs
358		* Default attributes to use with this handle. This parameter may be NULL.
359		* Certain atttributes may cause different handlers to be pushed onto the
360		* default handler chain for this client.
361		* @param handlers
362		* Handle chain to use with this handle. This parameter may be NULL.
363		* Typically the default handler chain used by this function is sufficient.
364		*/
365		globus_result_t
366		CounterService_client_init(
367		CounterService_client_handle_t * handle,
368		globus_soap_message_attr_t attrs,
369		globus_handler_chain_t chain)
370	17	{
371	17	CounterService_client_handle_t client_handle = NULL;
372	17	globus_result_t result = GLOBUS_SUCCESS;
373	17	globus_handler_chain_t tmp_chain = NULL;
374		GlobusFuncName(CounterService_client_init);
375	17	GlobusSoapMessageDebugEnter();
376
377	17	if (chain == NULL)
378		{
379	17	globus_handler_chain_init(&tmp_chain);
380
381	17	if(attrs &&
382		((int)globus_soap_message_attr_get(
383		attrs,
384		GLOBUS_SOAP_MESSAGE_AUTHENTICATION_METHOD_KEY)) ==
385		GLOBUS_SOAP_MESSAGE_AUTH_SECURE_MESSAGE)
386		{
387	0	result = globus_extension_activate(
388		"globus_handler_ws_secure_message");
389	0	if(result != GLOBUS_SUCCESS)
390		{
391	0	result = GlobusSoapMessageErrorFailedClientInit(
392		result, "CounterPortType_createCounter");
393	0	goto error;
394		}
395
396	0	globus_mutex_lock(&CounterService_l_extensions_mutex);
397	0	globus_list_insert(
398		&CounterService_l_extensions,
399		strdup("globus_handler_ws_secure_message"));
400	0	globus_mutex_unlock(&CounterService_l_extensions_mutex);
401
402	0	result = globus_handler_chain_push(
403		tmp_chain,
404		GLOBUS_HANDLER_TYPE_ALL,
405		"globus_handler_ws_secure_message_client");
406	0	if(result != GLOBUS_SUCCESS)
407		{
408	0	result = GlobusSoapMessageErrorFailedClientInit(
409		result, "CounterPortType_createCounter");
410	0	goto error;
411		}
412		}
413
414	17	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
415	17	if(result != GLOBUS_SUCCESS)
416		{
417	0	result = GlobusSoapMessageErrorFailedClientInit(
418		result, "CounterPortType_createCounter");
419	0	goto error;
420		}
421
422	17	globus_mutex_lock(&CounterService_l_extensions_mutex);
423	17	globus_list_insert(
424		&CounterService_l_extensions,
425		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
426	17	globus_mutex_unlock(&CounterService_l_extensions_mutex);
427
428	17	result = globus_handler_chain_push(
429		tmp_chain,
430		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
431		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
432	17	if(result != GLOBUS_SUCCESS)
433		{
434	0	result = GlobusSoapMessageErrorFailedClientInit(
435		result, "CounterPortType_createCounter");
436	0	goto error;
437		}
438
439	17	result = globus_handler_chain_push(
440		tmp_chain,
441		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
442		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
443	17	if(result != GLOBUS_SUCCESS)
444		{
445	0	result = GlobusSoapMessageErrorFailedClientInit(
446		result, "CounterPortType_createCounter");
447	0	goto error;
448		}
449
450	17	chain = tmp_chain;
451		}
452
453	17	result = globus_soap_client_handle_init(
454		handle,
455		attrs,
456		chain);
457
458	17	GlobusSoapMessageDebugExit();
459	17	return result;
460
461	0	error:
462	0	if (tmp_chain != NULL)
463		{
464	0	globus_handler_chain_destroy(tmp_chain);
465		}
466	0	if (client_handle != NULL)
467		{
468	0	globus_free(client_handle);
469		}
470	0	GlobusSoapMessageDebugExit();
471	0	return result;
472		}
473		/* CounterService_client_init() */
474
475		/**
476		* Destroy a client handle
477		* @ingroup CounterService_client_handle
478		*
479		* Destroys the state associated with this client handle.
480		*
481		* @param handle
482		* Handle to destroy.
483		*/
484		void
485		CounterService_client_destroy(
486		CounterService_client_handle_t handle)
487	17	{
488	17	globus_soap_client_handle_destroy(handle);
489	17	}
490
491		/**
492		* Cancel the current operation associated with this handle.
493		* @ingroup CounterService_client_handle
494		*
495		* @param handle
496		* Handle which has the operation to cancel.
497		*/
498		globus_result_t
499		CounterService_client_operation_cancel(
500		CounterService_client_handle_t handle)
501	0	{
502	0	globus_result_t result = GLOBUS_SUCCESS;
503		GlobusFuncName(CounterService_client_message_cancel);
504	0	GlobusSoapMessageDebugEnter();
505
506	0	result = globus_soap_client_operation_cancel(handle);
507
508	0	return result;
509		}
510
511		/**
512		* Get handle's handler chain
513		* @ingroup CounterService_client_handle
514		*
515		* The handler chain contains information about which handlers (typically
516		* SOAP header processors) will be invoked when a request is sent or a
517		* response is received. Applications which want to add custom handlers at
518		* run time may wish to push additional handlers onto this chain.
519		*
520		* @param handle
521		* The handle to query.
522		* @param handlers
523		* A pointer to a handler chain which will be set to the handle's
524		* chain.
525		*/
526		globus_result_t
527		CounterService_client_get_handler_chain(
528		CounterService_client_handle_t handle,
529		globus_handler_chain_t * handlers)
530	0	{
531	0	globus_result_t result = GLOBUS_SUCCESS;
532		GlobusFuncName(CounterService_client_get_handle_chain);
533	0	GlobusSoapMessageDebugEnter();
534
535	0	result = globus_soap_client_handle_get_handler_chain(handle, handlers);
536
537	0	GlobusSoapMessageDebugExit();
538	0	return result;
539		}
540
541		/**
542		* Set a SOAP attribute on a handle
543		* @ingroup CounterService_client_handle
544		*
545		* Set a SOAP attribute on a handle. This can be used to change how
546		* the SOAP engine will process operations sent via this handle.
547		*
548		* @param handle
549		* The handle to modify.
550		* @param prop_name
551		* The attribute name. This should be one of the
552		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
553		* @param copy
554		* A function to copy the value. This is required if @a value will go
555		* out of scope.
556		* @param destroy
557		* A function to destroy a copy of the value. Required if @a copy is set.
558		* @param value
559		* The new value of the attribute.
560		*/
561		globus_result_t
562		CounterService_client_attr_set(
563		CounterService_client_handle_t handle,
564		const char * prop_name,
565		globus_soap_message_attr_copy_func_t copy,
566		globus_soap_message_attr_destroy_func_t destroy,
567		void * value)
568	0	{
569	0	return globus_soap_client_handle_attr_set(
570		handle,
571		prop_name,
572		copy,
573		destroy,
574		value);
575		}
576
577		/**
578		* Remove a SOAP attribute from a handle
579		* @ingroup CounterService_client_handle
580		*
581		* Remove a SOAP attribute on a handle. This can be used to change how
582		* the SOAP engine will process operations sent via this handle.
583		*
584		* @param handle
585		* The handle to modify.
586		* @param prop_name
587		* The attribute name. This should be one of the
588		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
589		*
590		* @return
591		* This function returns the current value of the attribute.
592		*/
593		void *
594		CounterService_client_attr_remove(
595		CounterService_client_handle_t handle,
596		const char * prop_name)
597	0	{
598	0	return globus_soap_client_handle_attr_remove(
599		handle,
600		prop_name);
601		}
602
603		/**
604		* Get a SOAP attribute from a handle
605		* @ingroup CounterService_client_handle
606		*
607		* Get the current value of a SOAP attribute set on a handle.
608		*
609		* @param handle
610		* The handle to query.
611		* @param prop_name
612		* The attribute name. This should be one of the
613		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
614		*
615		* @return
616		* This function returns the current value of the attribute.
617		*/
618		void *
619		CounterService_client_attr_get(
620		CounterService_client_handle_t handle,
621		const char * prop_name)
622	0	{
623	0	return globus_soap_client_handle_attr_get(
624		handle,
625		prop_name);
626		}
627
628
629
630		/**
631		* Nonblocking operation request with EPR
632		* @ingroup CounterPortType_SetTerminationTime_operation
633		* Begin sending a request for the <code>SetTerminationTime</code> operation on a
634		* resource handled by the service named by the @a epr. When the operation
635		* request has been sent, the @a callback function will be invoked.
636		*
637		* @param client_handle
638		* The @link #CounterService_client_handle_t client handle @endlink which
639		* contains the state related to processing this operation.
640		* @param epr
641		* Endpoint Reference of the service and resource which will process
642		* the operation.
643		* @param input
644		* Input parameter to the operation.
645		* @param callback
646		* Callback function which will be called once the request has been
647		* sent
648		* @param callback_arg
649		* Application-specific pointer which will be passed to the callback.
650		*/
651		globus_result_t
652		CounterPortType_SetTerminationTime_epr_register_request(
653		CounterService_client_handle_t client_handle,
654		const wsa_EndpointReferenceType * epr,
655		const wsrl_SetTerminationTimeType * input,
656		CounterPortType_SetTerminationTime_request_callback_func_t callback,
657		void * callback_arg)
658	0	{
659	0	globus_result_t result = GLOBUS_SUCCESS;
660
661	0	globus_assert_string(epr, "NULL EndpointReference");
662	0	globus_assert_string(epr->Address.base_value,
663		"NULL EndpointReference Address");
664
665	0	result = globus_soap_client_handle_attr_set(
666		client_handle,
667		WSADDR_EPR_KEY,
668		wsa_EndpointReferenceType_info.copy,
669		wsa_EndpointReferenceType_info.destroy,
670		(void *) epr);
671
672	0	if (result != GLOBUS_SUCCESS)
673		{
674	0	goto out;
675		}
676
677	0	result = globus_soap_client_register_request(
678		client_handle,
679		epr->Address.base_value,
680		&CounterPortType_l_SetTerminationTime_operation,
681		(void *) input,
682		callback,
683		callback_arg);
684
685	0	out:
686	0	return result;
687		}
688
689		/**
690		* Nonblocking operation request
691		* @ingroup CounterPortType_SetTerminationTime_operation
692		* Begin sending a request for the <code>SetTerminationTime</code> operation to
693		* the service at @a endpoint. When the operation
694		* request has been sent, the @a callback function will be invoked.
695		* @param handle
696		* The @link #CounterService_client_handle_t client handle @endlink which
697		* contains the state related to processing this operation.
698		* @param endpoint
699		* URI of the service endpoint to send the request to.
700		* @param input
701		* Input parameter to the operation.
702		* @param callback
703		* Callback function which will be called once the request has been
704		* sent
705		* @param callback_arg
706		* Application-specific pointer which will be passed to the callback.
707		*/
708		globus_result_t
709		CounterPortType_SetTerminationTime_register_request(
710		CounterService_client_handle_t client_handle,
711		const char * endpoint,
712		const wsrl_SetTerminationTimeType * input,
713		CounterPortType_SetTerminationTime_request_callback_func_t callback,
714		void * callback_arg)
715	0	{
716	0	return globus_soap_client_register_request(
717		client_handle,
718		endpoint,
719		&CounterPortType_l_SetTerminationTime_operation,
720		(void *) input,
721		callback,
722		callback_arg);
723		}
724
725
726
727		static
728		void
729		CounterPortType_l_SetTerminationTime_deserialize_fault(
730		globus_soap_message_handle_t handle,
731		const xsd_QName * fault_qname,
732		int * fault_type)
733	0	{
734	0	*fault_type = COUNTERPORTTYPE_SETTERMINATIONTIME_NOFAULT;
735
736	0	if(fault_qname)
737		{
738	0	if(fault_qname == (&wsrl_TerminationTimeChangeRejectedFaultType_qname) ||
739		fault_qname == (&wsrl_TerminationTimeChangeRejectedFault_qname))
740		{
741	0	*fault_type = COUNTERPORTTYPE_SETTERMINATIONTIME_TERMINATIONTIMECHANGEREJECTEDFAULT;
742		}
743	0	else if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
744		fault_qname == (&wsr_ResourceUnknownFault_qname))
745		{
746	0	*fault_type = COUNTERPORTTYPE_SETTERMINATIONTIME_RESOURCEUNKNOWNFAULT;
747		}
748	0	else if(fault_qname == (&wsrl_UnableToSetTerminationTimeFaultType_qname) ||
749		fault_qname == (&wsrl_UnableToSetTerminationTimeFault_qname))
750		{
751	0	*fault_type = COUNTERPORTTYPE_SETTERMINATIONTIME_UNABLETOSETTERMINATIONTIMEFAULT;
752		}
753	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
754		fault_qname == (&wsr_ResourceUnavailableFault_qname))
755		{
756	0	*fault_type = COUNTERPORTTYPE_SETTERMINATIONTIME_RESOURCEUNAVAILABLEFAULT;
757		}
758		else
759		{
760	0	*fault_type = COUNTERPORTTYPE_SETTERMINATIONTIME_UNKNOWN_FAULT;
761		}
762		}
763	0	}
764		/* CounterPortType_l_SetTerminationTime_deserialize_fault() */
765
766		/**
767		* Nonblocking operation response handling
768		* @ingroup CounterPortType_SetTerminationTime_operation
769		* Begin parsing the request for the <code>SetTerminationTime</code> operation begun
770		* by an earlier call to
771		* CounterPortType_SetTerminationTime_register_request() or
772		* CounterPortType_SetTerminationTime_epr_register_request(). Once the response has been parsed.
773		* the @a callback function will be called to pass the result of the operation
774		* to the application.
775		*
776		* @param client_handle
777		* The @link #CounterService_client_handle_t client handle @endlink which
778		* contains the state related to processing this operation.
779		* @param callback
780		* Callback function which will be called once the response has been
781		* processed.
782		* @param callback_arg
783		* Application-specific pointer which will be passed to the callback.
784		*/
785		globus_result_t
786		CounterPortType_SetTerminationTime_register_response(
787		CounterService_client_handle_t client_handle,
788		CounterPortType_SetTerminationTime_response_callback_func_t callback,
789		void * callback_arg)
790	0	{
791	0	return globus_soap_client_register_response(
792		client_handle,
793		(globus_soap_client_response_callback_func_t) callback,
794		callback_arg);
795		}
796
797		/**
798		* Nonblocking operation invocation with EPR
799		* @ingroup CounterPortType_SetTerminationTime_operation
800		*
801		* Begin processing a request for the SetTerminationTime operation. The operation will
802		* sent to the service named by the @a epr and after the response is received,
803		* the @a callback function will be invoked.
804		*
805		* @param handle
806		* The @link #CounterService_client_handle_t client handle @endlink which
807		* contains the state related to processing this operation.
808		* @param epr
809		* Endpoint Reference of the service and resource which will process
810		* the operation.
811		* @param input
812		* Input parameter to the operation.
813		* @param callback
814		* Callback function which will be called once the operation has been
815		* processed.
816		* @param callback_arg
817		* Application-specific pointer which will be passed to the callback.
818		*/
819		globus_result_t
820		CounterPortType_SetTerminationTime_epr_register(
821		CounterService_client_handle_t handle,
822		const wsa_EndpointReferenceType * epr,
823		const wsrl_SetTerminationTimeType * input,
824		CounterPortType_SetTerminationTime_response_callback_func_t callback,
825		void * callback_arg)
826	0	{
827		globus_result_t result;
828
829	0	result = globus_soap_client_handle_attr_set(
830		handle,
831		WSADDR_EPR_KEY,
832		wsa_EndpointReferenceType_info.copy,
833		wsa_EndpointReferenceType_info.destroy,
834		(void *) epr);
835
836	0	if (result != GLOBUS_SUCCESS)
837		{
838	0	goto out;
839		}
840
841	0	result = globus_soap_client_operation_register(
842		handle,
843		epr->Address.base_value,
844		&CounterPortType_l_SetTerminationTime_operation,
845		(void *) input,
846		(globus_soap_client_response_callback_func_t) callback,
847		callback_arg);
848	0	out:
849	0	return result;
850		}
851
852		/**
853		* Nonblocking operation invocation
854		* @ingroup CounterPortType_SetTerminationTime_operation
855		*
856		* Begin processing a request for the SetTerminationTime operation. The operation will
857		* sent to the service located at @a endpoint and after the response is
858		* received, the @a callback function will be invoked.
859		*
860		* @param handle
861		* The @link #CounterService_client_handle_t client handle @endlink which
862		* contains the state related to processing this operation.
863		* @param endpoint
864		* URI of the service endpoint to send the request to.
865		* @param input
866		* Input parameter to the operation.
867		* @param callback
868		* Callback function which will be called once the operation has been
869		* processed.
870		* @param callback_arg
871		* Application-specific pointer which will be passed to the callback.
872		*/
873		globus_result_t
874		CounterPortType_SetTerminationTime_register(
875		CounterService_client_handle_t handle,
876		const char * endpoint,
877		const wsrl_SetTerminationTimeType * input,
878		CounterPortType_SetTerminationTime_response_callback_func_t callback,
879		void * callback_arg)
880	0	{
881	0	return globus_soap_client_operation_register(
882		handle,
883		endpoint,
884		&CounterPortType_l_SetTerminationTime_operation,
885		(void *) input,
886		(globus_soap_client_response_callback_func_t) callback,
887		callback_arg);
888		}
889
890
891
892		/**
893		* Blocking operation invocation with EPR
894		* @ingroup CounterPortType_SetTerminationTime_operation
895		*
896		* Request that an the SetTerminationTime operation be invoked by the service and
897		* resource named by the @a epr parameter.
898
899		* If the result is <code>GLOBUS_SUCCESS</code>, then the
900		* @a output parameter will be set to the result of the operation.
901		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
902		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
903		* error occurred, and the result's error type should be checked.
904
905		*
906		* @param handle
907		* The @link #CounterService_client_handle_t client handle @endlink which
908		* contains the state related to processing this operation.
909		* @param epr
910		* Endpoint Reference of the service and resource which will process
911		* the operation.
912		* @param input
913		* Input parameter to the operation.
914
915		* @param output
916		* The output of the operation, if the operation succeeded.
917		* @param fault_type
918		* The type of fault sent as a result of the operation, if the operation
919		* failed. If the operation succeeded, this will be NULL.
920		* @param fault
921		* The fault element which was received, if the operation failed.
922		* If the operation succeeded, this will be NULL.
923
924		*/
925		globus_result_t
926		CounterPortType_SetTerminationTime_epr(
927		CounterService_client_handle_t handle,
928		const wsa_EndpointReferenceType * epr,
929		const wsrl_SetTerminationTimeType * input,
930		wsrl_SetTerminationTimeResponseType * * output,
931		CounterPortType_SetTerminationTime_fault_t * fault_type,
932		xsd_any * * fault)
933	0	{
934		globus_result_t result;
935
936	0	result = globus_soap_client_handle_attr_set(
937		handle,
938		WSADDR_EPR_KEY,
939		wsa_EndpointReferenceType_info.copy,
940		wsa_EndpointReferenceType_info.destroy,
941		(void *) epr);
942
943	0	if (result != GLOBUS_SUCCESS)
944		{
945	0	goto out;
946		}
947	0	result = globus_soap_client_operation(
948		handle,
949		epr->Address.base_value,
950		&CounterPortType_l_SetTerminationTime_operation,
951		(void *) input,
952
953		(void **) output,
954		(int *) fault_type,
955		fault
956		);
957	0	out:
958	0	return result;
959		}
960
961		/**
962		* Blocking operation invocation
963		* @ingroup CounterPortType_SetTerminationTime_operation
964		*
965		* Request that an the SetTerminationTime operation be invoked by the service at
966		* @a endpoint.
967
968		* If the result is <code>GLOBUS_SUCCESS</code>, then the
969		* @a output parameter will be set to the result of the operation.
970		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
971		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
972		* error occurred, and the result's error type should be checked.
973
974		*
975		* @param handle
976		* The @link #CounterService_client_handle_t client handle @endlink which
977		* contains the state related to processing this operation.
978		* @param endpoint
979		* URI of the service endpoint to send the request to.
980		* @param input
981		* Input parameter to the operation.
982
983		* @param output
984		* The output of the operation, if the operation succeeded.
985		* @param fault_type
986		* The type of fault sent as a result of the operation, if the operation
987		* failed. If the operation succeeded, this will be NULL.
988		* @param fault
989		* The fault element which was received, if the operation failed.
990		* If the operation succeeded, this will be NULL.
991
992		*/
993		globus_result_t
994		CounterPortType_SetTerminationTime(
995		CounterService_client_handle_t handle,
996		const char * endpoint,
997		const wsrl_SetTerminationTimeType * input,
998		wsrl_SetTerminationTimeResponseType * * output,
999		CounterPortType_SetTerminationTime_fault_t * fault_type,
1000		xsd_any * * fault)
1001	0	{
1002	0	return globus_soap_client_operation(
1003		handle,
1004		endpoint,
1005		&CounterPortType_l_SetTerminationTime_operation,
1006		(void *) input,
1007
1008		(void *) output,
1009		(int *) fault_type,
1010		fault
1011		);
1012		}
1013
1014
1015		/**
1016		* Nonblocking operation request with EPR
1017		* @ingroup CounterPortType_Destroy_operation
1018		* Begin sending a request for the <code>Destroy</code> operation on a
1019		* resource handled by the service named by the @a epr. When the operation
1020		* request has been sent, the @a callback function will be invoked.
1021		*
1022		* @param client_handle
1023		* The @link #CounterService_client_handle_t client handle @endlink which
1024		* contains the state related to processing this operation.
1025		* @param epr
1026		* Endpoint Reference of the service and resource which will process
1027		* the operation.
1028		* @param input
1029		* Input parameter to the operation.
1030		* @param callback
1031		* Callback function which will be called once the request has been
1032		* sent
1033		* @param callback_arg
1034		* Application-specific pointer which will be passed to the callback.
1035		*/
1036		globus_result_t
1037		CounterPortType_Destroy_epr_register_request(
1038		CounterService_client_handle_t client_handle,
1039		const wsa_EndpointReferenceType * epr,
1040		const wsrl_DestroyType * input,
1041		CounterPortType_Destroy_request_callback_func_t callback,
1042		void * callback_arg)
1043	0	{
1044	0	globus_result_t result = GLOBUS_SUCCESS;
1045
1046	0	globus_assert_string(epr, "NULL EndpointReference");
1047	0	globus_assert_string(epr->Address.base_value,
1048		"NULL EndpointReference Address");
1049
1050	0	result = globus_soap_client_handle_attr_set(
1051		client_handle,
1052		WSADDR_EPR_KEY,
1053		wsa_EndpointReferenceType_info.copy,
1054		wsa_EndpointReferenceType_info.destroy,
1055		(void *) epr);
1056
1057	0	if (result != GLOBUS_SUCCESS)
1058		{
1059	0	goto out;
1060		}
1061
1062	0	result = globus_soap_client_register_request(
1063		client_handle,
1064		epr->Address.base_value,
1065		&CounterPortType_l_Destroy_operation,
1066		(void *) input,
1067		callback,
1068		callback_arg);
1069
1070	0	out:
1071	0	return result;
1072		}
1073
1074		/**
1075		* Nonblocking operation request
1076		* @ingroup CounterPortType_Destroy_operation
1077		* Begin sending a request for the <code>Destroy</code> operation to
1078		* the service at @a endpoint. When the operation
1079		* request has been sent, the @a callback function will be invoked.
1080		* @param handle
1081		* The @link #CounterService_client_handle_t client handle @endlink which
1082		* contains the state related to processing this operation.
1083		* @param endpoint
1084		* URI of the service endpoint to send the request to.
1085		* @param input
1086		* Input parameter to the operation.
1087		* @param callback
1088		* Callback function which will be called once the request has been
1089		* sent
1090		* @param callback_arg
1091		* Application-specific pointer which will be passed to the callback.
1092		*/
1093		globus_result_t
1094		CounterPortType_Destroy_register_request(
1095		CounterService_client_handle_t client_handle,
1096		const char * endpoint,
1097		const wsrl_DestroyType * input,
1098		CounterPortType_Destroy_request_callback_func_t callback,
1099		void * callback_arg)
1100	0	{
1101	0	return globus_soap_client_register_request(
1102		client_handle,
1103		endpoint,
1104		&CounterPortType_l_Destroy_operation,
1105		(void *) input,
1106		callback,
1107		callback_arg);
1108		}
1109
1110
1111
1112		static
1113		void
1114		CounterPortType_l_Destroy_deserialize_fault(
1115		globus_soap_message_handle_t handle,
1116		const xsd_QName * fault_qname,
1117		int * fault_type)
1118	0	{
1119	0	*fault_type = COUNTERPORTTYPE_DESTROY_NOFAULT;
1120
1121	0	if(fault_qname)
1122		{
1123	0	if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
1124		fault_qname == (&wsr_ResourceUnknownFault_qname))
1125		{
1126	0	*fault_type = COUNTERPORTTYPE_DESTROY_RESOURCEUNKNOWNFAULT;
1127		}
1128	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
1129		fault_qname == (&wsr_ResourceUnavailableFault_qname))
1130		{
1131	0	*fault_type = COUNTERPORTTYPE_DESTROY_RESOURCEUNAVAILABLEFAULT;
1132		}
1133	0	else if(fault_qname == (&wsrl_ResourceNotDestroyedFaultType_qname) ||
1134		fault_qname == (&wsrl_ResourceNotDestroyedFault_qname))
1135		{
1136	0	*fault_type = COUNTERPORTTYPE_DESTROY_RESOURCENOTDESTROYEDFAULT;
1137		}
1138		else
1139		{
1140	0	*fault_type = COUNTERPORTTYPE_DESTROY_UNKNOWN_FAULT;
1141		}
1142		}
1143	0	}
1144		/* CounterPortType_l_Destroy_deserialize_fault() */
1145
1146		/**
1147		* Nonblocking operation response handling
1148		* @ingroup CounterPortType_Destroy_operation
1149		* Begin parsing the request for the <code>Destroy</code> operation begun
1150		* by an earlier call to
1151		* CounterPortType_Destroy_register_request() or
1152		* CounterPortType_Destroy_epr_register_request(). Once the response has been parsed.
1153		* the @a callback function will be called to pass the result of the operation
1154		* to the application.
1155		*
1156		* @param client_handle
1157		* The @link #CounterService_client_handle_t client handle @endlink which
1158		* contains the state related to processing this operation.
1159		* @param callback
1160		* Callback function which will be called once the response has been
1161		* processed.
1162		* @param callback_arg
1163		* Application-specific pointer which will be passed to the callback.
1164		*/
1165		globus_result_t
1166		CounterPortType_Destroy_register_response(
1167		CounterService_client_handle_t client_handle,
1168		CounterPortType_Destroy_response_callback_func_t callback,
1169		void * callback_arg)
1170	0	{
1171	0	return globus_soap_client_register_response(
1172		client_handle,
1173		(globus_soap_client_response_callback_func_t) callback,
1174		callback_arg);
1175		}
1176
1177		/**
1178		* Nonblocking operation invocation with EPR
1179		* @ingroup CounterPortType_Destroy_operation
1180		*
1181		* Begin processing a request for the Destroy operation. The operation will
1182		* sent to the service named by the @a epr and after the response is received,
1183		* the @a callback function will be invoked.
1184		*
1185		* @param handle
1186		* The @link #CounterService_client_handle_t client handle @endlink which
1187		* contains the state related to processing this operation.
1188		* @param epr
1189		* Endpoint Reference of the service and resource which will process
1190		* the operation.
1191		* @param input
1192		* Input parameter to the operation.
1193		* @param callback
1194		* Callback function which will be called once the operation has been
1195		* processed.
1196		* @param callback_arg
1197		* Application-specific pointer which will be passed to the callback.
1198		*/
1199		globus_result_t
1200		CounterPortType_Destroy_epr_register(
1201		CounterService_client_handle_t handle,
1202		const wsa_EndpointReferenceType * epr,
1203		const wsrl_DestroyType * input,
1204		CounterPortType_Destroy_response_callback_func_t callback,
1205		void * callback_arg)
1206	0	{
1207		globus_result_t result;
1208
1209	0	result = globus_soap_client_handle_attr_set(
1210		handle,
1211		WSADDR_EPR_KEY,
1212		wsa_EndpointReferenceType_info.copy,
1213		wsa_EndpointReferenceType_info.destroy,
1214		(void *) epr);
1215
1216	0	if (result != GLOBUS_SUCCESS)
1217		{
1218	0	goto out;
1219		}
1220
1221	0	result = globus_soap_client_operation_register(
1222		handle,
1223		epr->Address.base_value,
1224		&CounterPortType_l_Destroy_operation,
1225		(void *) input,
1226		(globus_soap_client_response_callback_func_t) callback,
1227		callback_arg);
1228	0	out:
1229	0	return result;
1230		}
1231
1232		/**
1233		* Nonblocking operation invocation
1234		* @ingroup CounterPortType_Destroy_operation
1235		*
1236		* Begin processing a request for the Destroy operation. The operation will
1237		* sent to the service located at @a endpoint and after the response is
1238		* received, the @a callback function will be invoked.
1239		*
1240		* @param handle
1241		* The @link #CounterService_client_handle_t client handle @endlink which
1242		* contains the state related to processing this operation.
1243		* @param endpoint
1244		* URI of the service endpoint to send the request to.
1245		* @param input
1246		* Input parameter to the operation.
1247		* @param callback
1248		* Callback function which will be called once the operation has been
1249		* processed.
1250		* @param callback_arg
1251		* Application-specific pointer which will be passed to the callback.
1252		*/
1253		globus_result_t
1254		CounterPortType_Destroy_register(
1255		CounterService_client_handle_t handle,
1256		const char * endpoint,
1257		const wsrl_DestroyType * input,
1258		CounterPortType_Destroy_response_callback_func_t callback,
1259		void * callback_arg)
1260	0	{
1261	0	return globus_soap_client_operation_register(
1262		handle,
1263		endpoint,
1264		&CounterPortType_l_Destroy_operation,
1265		(void *) input,
1266		(globus_soap_client_response_callback_func_t) callback,
1267		callback_arg);
1268		}
1269
1270
1271
1272		/**
1273		* Blocking operation invocation with EPR
1274		* @ingroup CounterPortType_Destroy_operation
1275		*
1276		* Request that an the Destroy operation be invoked by the service and
1277		* resource named by the @a epr parameter.
1278
1279		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1280		* @a output parameter will be set to the result of the operation.
1281		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1282		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1283		* error occurred, and the result's error type should be checked.
1284
1285		*
1286		* @param handle
1287		* The @link #CounterService_client_handle_t client handle @endlink which
1288		* contains the state related to processing this operation.
1289		* @param epr
1290		* Endpoint Reference of the service and resource which will process
1291		* the operation.
1292		* @param input
1293		* Input parameter to the operation.
1294
1295		* @param output
1296		* The output of the operation, if the operation succeeded.
1297		* @param fault_type
1298		* The type of fault sent as a result of the operation, if the operation
1299		* failed. If the operation succeeded, this will be NULL.
1300		* @param fault
1301		* The fault element which was received, if the operation failed.
1302		* If the operation succeeded, this will be NULL.
1303
1304		*/
1305		globus_result_t
1306		CounterPortType_Destroy_epr(
1307		CounterService_client_handle_t handle,
1308		const wsa_EndpointReferenceType * epr,
1309		const wsrl_DestroyType * input,
1310		wsrl_DestroyResponseType * * output,
1311		CounterPortType_Destroy_fault_t * fault_type,
1312		xsd_any * * fault)
1313	10	{
1314		globus_result_t result;
1315
1316	10	result = globus_soap_client_handle_attr_set(
1317		handle,
1318		WSADDR_EPR_KEY,
1319		wsa_EndpointReferenceType_info.copy,
1320		wsa_EndpointReferenceType_info.destroy,
1321		(void *) epr);
1322
1323	10	if (result != GLOBUS_SUCCESS)
1324		{
1325	0	goto out;
1326		}
1327	10	result = globus_soap_client_operation(
1328		handle,
1329		epr->Address.base_value,
1330		&CounterPortType_l_Destroy_operation,
1331		(void *) input,
1332
1333		(void **) output,
1334		(int *) fault_type,
1335		fault
1336		);
1337	10	out:
1338	10	return result;
1339		}
1340
1341		/**
1342		* Blocking operation invocation
1343		* @ingroup CounterPortType_Destroy_operation
1344		*
1345		* Request that an the Destroy operation be invoked by the service at
1346		* @a endpoint.
1347
1348		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1349		* @a output parameter will be set to the result of the operation.
1350		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1351		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1352		* error occurred, and the result's error type should be checked.
1353
1354		*
1355		* @param handle
1356		* The @link #CounterService_client_handle_t client handle @endlink which
1357		* contains the state related to processing this operation.
1358		* @param endpoint
1359		* URI of the service endpoint to send the request to.
1360		* @param input
1361		* Input parameter to the operation.
1362
1363		* @param output
1364		* The output of the operation, if the operation succeeded.
1365		* @param fault_type
1366		* The type of fault sent as a result of the operation, if the operation
1367		* failed. If the operation succeeded, this will be NULL.
1368		* @param fault
1369		* The fault element which was received, if the operation failed.
1370		* If the operation succeeded, this will be NULL.
1371
1372		*/
1373		globus_result_t
1374		CounterPortType_Destroy(
1375		CounterService_client_handle_t handle,
1376		const char * endpoint,
1377		const wsrl_DestroyType * input,
1378		wsrl_DestroyResponseType * * output,
1379		CounterPortType_Destroy_fault_t * fault_type,
1380		xsd_any * * fault)
1381	0	{
1382	0	return globus_soap_client_operation(
1383		handle,
1384		endpoint,
1385		&CounterPortType_l_Destroy_operation,
1386		(void *) input,
1387
1388		(void *) output,
1389		(int *) fault_type,
1390		fault
1391		);
1392		}
1393
1394
1395		/**
1396		* Nonblocking operation request with EPR
1397		* @ingroup CounterPortType_GetCurrentMessage_operation
1398		* Begin sending a request for the <code>GetCurrentMessage</code> operation on a
1399		* resource handled by the service named by the @a epr. When the operation
1400		* request has been sent, the @a callback function will be invoked.
1401		*
1402		* @param client_handle
1403		* The @link #CounterService_client_handle_t client handle @endlink which
1404		* contains the state related to processing this operation.
1405		* @param epr
1406		* Endpoint Reference of the service and resource which will process
1407		* the operation.
1408		* @param input
1409		* Input parameter to the operation.
1410		* @param callback
1411		* Callback function which will be called once the request has been
1412		* sent
1413		* @param callback_arg
1414		* Application-specific pointer which will be passed to the callback.
1415		*/
1416		globus_result_t
1417		CounterPortType_GetCurrentMessage_epr_register_request(
1418		CounterService_client_handle_t client_handle,
1419		const wsa_EndpointReferenceType * epr,
1420		const wsnt_GetCurrentMessageType * input,
1421		CounterPortType_GetCurrentMessage_request_callback_func_t callback,
1422		void * callback_arg)
1423	0	{
1424	0	globus_result_t result = GLOBUS_SUCCESS;
1425
1426	0	globus_assert_string(epr, "NULL EndpointReference");
1427	0	globus_assert_string(epr->Address.base_value,
1428		"NULL EndpointReference Address");
1429
1430	0	result = globus_soap_client_handle_attr_set(
1431		client_handle,
1432		WSADDR_EPR_KEY,
1433		wsa_EndpointReferenceType_info.copy,
1434		wsa_EndpointReferenceType_info.destroy,
1435		(void *) epr);
1436
1437	0	if (result != GLOBUS_SUCCESS)
1438		{
1439	0	goto out;
1440		}
1441
1442	0	result = globus_soap_client_register_request(
1443		client_handle,
1444		epr->Address.base_value,
1445		&CounterPortType_l_GetCurrentMessage_operation,
1446		(void *) input,
1447		callback,
1448		callback_arg);
1449
1450	0	out:
1451	0	return result;
1452		}
1453
1454		/**
1455		* Nonblocking operation request
1456		* @ingroup CounterPortType_GetCurrentMessage_operation
1457		* Begin sending a request for the <code>GetCurrentMessage</code> operation to
1458		* the service at @a endpoint. When the operation
1459		* request has been sent, the @a callback function will be invoked.
1460		* @param handle
1461		* The @link #CounterService_client_handle_t client handle @endlink which
1462		* contains the state related to processing this operation.
1463		* @param endpoint
1464		* URI of the service endpoint to send the request to.
1465		* @param input
1466		* Input parameter to the operation.
1467		* @param callback
1468		* Callback function which will be called once the request has been
1469		* sent
1470		* @param callback_arg
1471		* Application-specific pointer which will be passed to the callback.
1472		*/
1473		globus_result_t
1474		CounterPortType_GetCurrentMessage_register_request(
1475		CounterService_client_handle_t client_handle,
1476		const char * endpoint,
1477		const wsnt_GetCurrentMessageType * input,
1478		CounterPortType_GetCurrentMessage_request_callback_func_t callback,
1479		void * callback_arg)
1480	0	{
1481	0	return globus_soap_client_register_request(
1482		client_handle,
1483		endpoint,
1484		&CounterPortType_l_GetCurrentMessage_operation,
1485		(void *) input,
1486		callback,
1487		callback_arg);
1488		}
1489
1490
1491
1492		static
1493		void
1494		CounterPortType_l_GetCurrentMessage_deserialize_fault(
1495		globus_soap_message_handle_t handle,
1496		const xsd_QName * fault_qname,
1497		int * fault_type)
1498	0	{
1499	0	*fault_type = COUNTERPORTTYPE_GETCURRENTMESSAGE_NOFAULT;
1500
1501	0	if(fault_qname)
1502		{
1503	0	if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
1504		fault_qname == (&wsr_ResourceUnknownFault_qname))
1505		{
1506	0	*fault_type = COUNTERPORTTYPE_GETCURRENTMESSAGE_RESOURCEUNKNOWNFAULT;
1507		}
1508	0	else if(fault_qname == (&wsnt_TopicExpressionDialectUnknownFaultType_qname) ||
1509		fault_qname == (&wsnt_TopicExpressionDialectUnknownFault_qname))
1510		{
1511	0	*fault_type = COUNTERPORTTYPE_GETCURRENTMESSAGE_TOPICEXPRESSIONDIALECTUNKNOWNFAULT;
1512		}
1513	0	else if(fault_qname == (&wsnt_NoCurrentMessageOnTopicFaultType_qname) ||
1514		fault_qname == (&wsnt_NoCurrentMessageOnTopicFault_qname))
1515		{
1516	0	*fault_type = COUNTERPORTTYPE_GETCURRENTMESSAGE_NOCURRENTMESSAGEONTOPICFAULT;
1517		}
1518	0	else if(fault_qname == (&wsnt_InvalidTopicExpressionFaultType_qname) ||
1519		fault_qname == (&wsnt_InvalidTopicExpressionFault_qname))
1520		{
1521	0	*fault_type = COUNTERPORTTYPE_GETCURRENTMESSAGE_INVALIDTOPICEXPRESSIONFAULT;
1522		}
1523	0	else if(fault_qname == (&wsnt_TopicNotSupportedFaultType_qname) ||
1524		fault_qname == (&wsnt_TopicNotSupportedFault_qname))
1525		{
1526	0	*fault_type = COUNTERPORTTYPE_GETCURRENTMESSAGE_TOPICNOTSUPPORTEDFAULT;
1527		}
1528	0	else if(fault_qname == (&wsnt_MultipleTopicsSpecifiedFaultType_qname) ||
1529		fault_qname == (&wsnt_MultipleTopicsSpecifiedFault_qname))
1530		{
1531	0	*fault_type = COUNTERPORTTYPE_GETCURRENTMESSAGE_MULTIPLETOPICSSPECIFIEDFAULT;
1532		}
1533		else
1534		{
1535	0	*fault_type = COUNTERPORTTYPE_GETCURRENTMESSAGE_UNKNOWN_FAULT;
1536		}
1537		}
1538	0	}
1539		/* CounterPortType_l_GetCurrentMessage_deserialize_fault() */
1540
1541		/**
1542		* Nonblocking operation response handling
1543		* @ingroup CounterPortType_GetCurrentMessage_operation
1544		* Begin parsing the request for the <code>GetCurrentMessage</code> operation begun
1545		* by an earlier call to
1546		* CounterPortType_GetCurrentMessage_register_request() or
1547		* CounterPortType_GetCurrentMessage_epr_register_request(). Once the response has been parsed.
1548		* the @a callback function will be called to pass the result of the operation
1549		* to the application.
1550		*
1551		* @param client_handle
1552		* The @link #CounterService_client_handle_t client handle @endlink which
1553		* contains the state related to processing this operation.
1554		* @param callback
1555		* Callback function which will be called once the response has been
1556		* processed.
1557		* @param callback_arg
1558		* Application-specific pointer which will be passed to the callback.
1559		*/
1560		globus_result_t
1561		CounterPortType_GetCurrentMessage_register_response(
1562		CounterService_client_handle_t client_handle,
1563		CounterPortType_GetCurrentMessage_response_callback_func_t callback,
1564		void * callback_arg)
1565	0	{
1566	0	return globus_soap_client_register_response(
1567		client_handle,
1568		(globus_soap_client_response_callback_func_t) callback,
1569		callback_arg);
1570		}
1571
1572		/**
1573		* Nonblocking operation invocation with EPR
1574		* @ingroup CounterPortType_GetCurrentMessage_operation
1575		*
1576		* Begin processing a request for the GetCurrentMessage operation. The operation will
1577		* sent to the service named by the @a epr and after the response is received,
1578		* the @a callback function will be invoked.
1579		*
1580		* @param handle
1581		* The @link #CounterService_client_handle_t client handle @endlink which
1582		* contains the state related to processing this operation.
1583		* @param epr
1584		* Endpoint Reference of the service and resource which will process
1585		* the operation.
1586		* @param input
1587		* Input parameter to the operation.
1588		* @param callback
1589		* Callback function which will be called once the operation has been
1590		* processed.
1591		* @param callback_arg
1592		* Application-specific pointer which will be passed to the callback.
1593		*/
1594		globus_result_t
1595		CounterPortType_GetCurrentMessage_epr_register(
1596		CounterService_client_handle_t handle,
1597		const wsa_EndpointReferenceType * epr,
1598		const wsnt_GetCurrentMessageType * input,
1599		CounterPortType_GetCurrentMessage_response_callback_func_t callback,
1600		void * callback_arg)
1601	0	{
1602		globus_result_t result;
1603
1604	0	result = globus_soap_client_handle_attr_set(
1605		handle,
1606		WSADDR_EPR_KEY,
1607		wsa_EndpointReferenceType_info.copy,
1608		wsa_EndpointReferenceType_info.destroy,
1609		(void *) epr);
1610
1611	0	if (result != GLOBUS_SUCCESS)
1612		{
1613	0	goto out;
1614		}
1615
1616	0	result = globus_soap_client_operation_register(
1617		handle,
1618		epr->Address.base_value,
1619		&CounterPortType_l_GetCurrentMessage_operation,
1620		(void *) input,
1621		(globus_soap_client_response_callback_func_t) callback,
1622		callback_arg);
1623	0	out:
1624	0	return result;
1625		}
1626
1627		/**
1628		* Nonblocking operation invocation
1629		* @ingroup CounterPortType_GetCurrentMessage_operation
1630		*
1631		* Begin processing a request for the GetCurrentMessage operation. The operation will
1632		* sent to the service located at @a endpoint and after the response is
1633		* received, the @a callback function will be invoked.
1634		*
1635		* @param handle
1636		* The @link #CounterService_client_handle_t client handle @endlink which
1637		* contains the state related to processing this operation.
1638		* @param endpoint
1639		* URI of the service endpoint to send the request to.
1640		* @param input
1641		* Input parameter to the operation.
1642		* @param callback
1643		* Callback function which will be called once the operation has been
1644		* processed.
1645		* @param callback_arg
1646		* Application-specific pointer which will be passed to the callback.
1647		*/
1648		globus_result_t
1649		CounterPortType_GetCurrentMessage_register(
1650		CounterService_client_handle_t handle,
1651		const char * endpoint,
1652		const wsnt_GetCurrentMessageType * input,
1653		CounterPortType_GetCurrentMessage_response_callback_func_t callback,
1654		void * callback_arg)
1655	0	{
1656	0	return globus_soap_client_operation_register(
1657		handle,
1658		endpoint,
1659		&CounterPortType_l_GetCurrentMessage_operation,
1660		(void *) input,
1661		(globus_soap_client_response_callback_func_t) callback,
1662		callback_arg);
1663		}
1664
1665
1666
1667		/**
1668		* Blocking operation invocation with EPR
1669		* @ingroup CounterPortType_GetCurrentMessage_operation
1670		*
1671		* Request that an the GetCurrentMessage operation be invoked by the service and
1672		* resource named by the @a epr parameter.
1673
1674		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1675		* @a output parameter will be set to the result of the operation.
1676		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1677		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1678		* error occurred, and the result's error type should be checked.
1679
1680		*
1681		* @param handle
1682		* The @link #CounterService_client_handle_t client handle @endlink which
1683		* contains the state related to processing this operation.
1684		* @param epr
1685		* Endpoint Reference of the service and resource which will process
1686		* the operation.
1687		* @param input
1688		* Input parameter to the operation.
1689
1690		* @param output
1691		* The output of the operation, if the operation succeeded.
1692		* @param fault_type
1693		* The type of fault sent as a result of the operation, if the operation
1694		* failed. If the operation succeeded, this will be NULL.
1695		* @param fault
1696		* The fault element which was received, if the operation failed.
1697		* If the operation succeeded, this will be NULL.
1698
1699		*/
1700		globus_result_t
1701		CounterPortType_GetCurrentMessage_epr(
1702		CounterService_client_handle_t handle,
1703		const wsa_EndpointReferenceType * epr,
1704		const wsnt_GetCurrentMessageType * input,
1705		wsnt_GetCurrentMessageResponseType * * output,
1706		CounterPortType_GetCurrentMessage_fault_t * fault_type,
1707		xsd_any * * fault)
1708	0	{
1709		globus_result_t result;
1710
1711	0	result = globus_soap_client_handle_attr_set(
1712		handle,
1713		WSADDR_EPR_KEY,
1714		wsa_EndpointReferenceType_info.copy,
1715		wsa_EndpointReferenceType_info.destroy,
1716		(void *) epr);
1717
1718	0	if (result != GLOBUS_SUCCESS)
1719		{
1720	0	goto out;
1721		}
1722	0	result = globus_soap_client_operation(
1723		handle,
1724		epr->Address.base_value,
1725		&CounterPortType_l_GetCurrentMessage_operation,
1726		(void *) input,
1727
1728		(void **) output,
1729		(int *) fault_type,
1730		fault
1731		);
1732	0	out:
1733	0	return result;
1734		}
1735
1736		/**
1737		* Blocking operation invocation
1738		* @ingroup CounterPortType_GetCurrentMessage_operation
1739		*
1740		* Request that an the GetCurrentMessage operation be invoked by the service at
1741		* @a endpoint.
1742
1743		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1744		* @a output parameter will be set to the result of the operation.
1745		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1746		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1747		* error occurred, and the result's error type should be checked.
1748
1749		*
1750		* @param handle
1751		* The @link #CounterService_client_handle_t client handle @endlink which
1752		* contains the state related to processing this operation.
1753		* @param endpoint
1754		* URI of the service endpoint to send the request to.
1755		* @param input
1756		* Input parameter to the operation.
1757
1758		* @param output
1759		* The output of the operation, if the operation succeeded.
1760		* @param fault_type
1761		* The type of fault sent as a result of the operation, if the operation
1762		* failed. If the operation succeeded, this will be NULL.
1763		* @param fault
1764		* The fault element which was received, if the operation failed.
1765		* If the operation succeeded, this will be NULL.
1766
1767		*/
1768		globus_result_t
1769		CounterPortType_GetCurrentMessage(
1770		CounterService_client_handle_t handle,
1771		const char * endpoint,
1772		const wsnt_GetCurrentMessageType * input,
1773		wsnt_GetCurrentMessageResponseType * * output,
1774		CounterPortType_GetCurrentMessage_fault_t * fault_type,
1775		xsd_any * * fault)
1776	0	{
1777	0	return globus_soap_client_operation(
1778		handle,
1779		endpoint,
1780		&CounterPortType_l_GetCurrentMessage_operation,
1781		(void *) input,
1782
1783		(void *) output,
1784		(int *) fault_type,
1785		fault
1786		);
1787		}
1788
1789
1790		/**
1791		* Nonblocking operation request with EPR
1792		* @ingroup CounterPortType_Subscribe_operation
1793		* Begin sending a request for the <code>Subscribe</code> operation on a
1794		* resource handled by the service named by the @a epr. When the operation
1795		* request has been sent, the @a callback function will be invoked.
1796		*
1797		* @param client_handle
1798		* The @link #CounterService_client_handle_t client handle @endlink which
1799		* contains the state related to processing this operation.
1800		* @param epr
1801		* Endpoint Reference of the service and resource which will process
1802		* the operation.
1803		* @param input
1804		* Input parameter to the operation.
1805		* @param callback
1806		* Callback function which will be called once the request has been
1807		* sent
1808		* @param callback_arg
1809		* Application-specific pointer which will be passed to the callback.
1810		*/
1811		globus_result_t
1812		CounterPortType_Subscribe_epr_register_request(
1813		CounterService_client_handle_t client_handle,
1814		const wsa_EndpointReferenceType * epr,
1815		const wsnt_SubscribeType * input,
1816		CounterPortType_Subscribe_request_callback_func_t callback,
1817		void * callback_arg)
1818	0	{
1819	0	globus_result_t result = GLOBUS_SUCCESS;
1820
1821	0	globus_assert_string(epr, "NULL EndpointReference");
1822	0	globus_assert_string(epr->Address.base_value,
1823		"NULL EndpointReference Address");
1824
1825	0	result = globus_soap_client_handle_attr_set(
1826		client_handle,
1827		WSADDR_EPR_KEY,
1828		wsa_EndpointReferenceType_info.copy,
1829		wsa_EndpointReferenceType_info.destroy,
1830		(void *) epr);
1831
1832	0	if (result != GLOBUS_SUCCESS)
1833		{
1834	0	goto out;
1835		}
1836
1837	0	result = globus_soap_client_register_request(
1838		client_handle,
1839		epr->Address.base_value,
1840		&CounterPortType_l_Subscribe_operation,
1841		(void *) input,
1842		callback,
1843		callback_arg);
1844
1845	0	out:
1846	0	return result;
1847		}
1848
1849		/**
1850		* Nonblocking operation request
1851		* @ingroup CounterPortType_Subscribe_operation
1852		* Begin sending a request for the <code>Subscribe</code> operation to
1853		* the service at @a endpoint. When the operation
1854		* request has been sent, the @a callback function will be invoked.
1855		* @param handle
1856		* The @link #CounterService_client_handle_t client handle @endlink which
1857		* contains the state related to processing this operation.
1858		* @param endpoint
1859		* URI of the service endpoint to send the request to.
1860		* @param input
1861		* Input parameter to the operation.
1862		* @param callback
1863		* Callback function which will be called once the request has been
1864		* sent
1865		* @param callback_arg
1866		* Application-specific pointer which will be passed to the callback.
1867		*/
1868		globus_result_t
1869		CounterPortType_Subscribe_register_request(
1870		CounterService_client_handle_t client_handle,
1871		const char * endpoint,
1872		const wsnt_SubscribeType * input,
1873		CounterPortType_Subscribe_request_callback_func_t callback,
1874		void * callback_arg)
1875	0	{
1876	0	return globus_soap_client_register_request(
1877		client_handle,
1878		endpoint,
1879		&CounterPortType_l_Subscribe_operation,
1880		(void *) input,
1881		callback,
1882		callback_arg);
1883		}
1884
1885
1886
1887		static
1888		void
1889		CounterPortType_l_Subscribe_deserialize_fault(
1890		globus_soap_message_handle_t handle,
1891		const xsd_QName * fault_qname,
1892		int * fault_type)
1893	0	{
1894	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_NOFAULT;
1895
1896	0	if(fault_qname)
1897		{
1898	0	if(fault_qname == (&wsnt_UnrecognizedPolicyRequestFaultType_qname) ||
1899		fault_qname == (&wsnt_UnrecognizedPolicyRequestFault_qname))
1900		{
1901	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_UNRECOGNIZEDPOLICYREQUESTFAULT;
1902		}
1903	0	else if(fault_qname == (&wsnt_NotifyMessageNotSupportedFaultType_qname) ||
1904		fault_qname == (&wsnt_NotifyMessageNotSupportedFault_qname))
1905		{
1906	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_NOTIFYMESSAGENOTSUPPORTEDFAULT;
1907		}
1908	0	else if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
1909		fault_qname == (&wsr_ResourceUnknownFault_qname))
1910		{
1911	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_RESOURCEUNKNOWNFAULT;
1912		}
1913	0	else if(fault_qname == (&wsnt_InvalidFilterFaultType_qname) ||
1914		fault_qname == (&wsnt_InvalidFilterFault_qname))
1915		{
1916	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_INVALIDFILTERFAULT;
1917		}
1918	0	else if(fault_qname == (&wsnt_TopicExpressionDialectUnknownFaultType_qname) ||
1919		fault_qname == (&wsnt_TopicExpressionDialectUnknownFault_qname))
1920		{
1921	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_TOPICEXPRESSIONDIALECTUNKNOWNFAULT;
1922		}
1923	0	else if(fault_qname == (&wsnt_SubscribeCreationFailedFaultType_qname) ||
1924		fault_qname == (&wsnt_SubscribeCreationFailedFault_qname))
1925		{
1926	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_SUBSCRIBECREATIONFAILEDFAULT;
1927		}
1928	0	else if(fault_qname == (&wsnt_InvalidProducerPropertiesExpressionFaultType_qname) ||
1929		fault_qname == (&wsnt_InvalidProducerPropertiesExpressionFault_qname))
1930		{
1931	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_INVALIDPRODUCERPROPERTIESEXPRESSIONFAULT;
1932		}
1933	0	else if(fault_qname == (&wsnt_InvalidMessageContentExpressionFaultType_qname) ||
1934		fault_qname == (&wsnt_InvalidMessageContentExpressionFault_qname))
1935		{
1936	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_INVALIDMESSAGECONTENTEXPRESSIONFAULT;
1937		}
1938	0	else if(fault_qname == (&wsnt_UnacceptableInitialTerminationTimeFaultType_qname) ||
1939		fault_qname == (&wsnt_UnacceptableInitialTerminationTimeFault_qname))
1940		{
1941	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_UNACCEPTABLEINITIALTERMINATIONTIMEFAULT;
1942		}
1943	0	else if(fault_qname == (&wsnt_UnsupportedPolicyRequestFaultType_qname) ||
1944		fault_qname == (&wsnt_UnsupportedPolicyRequestFault_qname))
1945		{
1946	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_UNSUPPORTEDPOLICYREQUESTFAULT;
1947		}
1948	0	else if(fault_qname == (&wsnt_InvalidTopicExpressionFaultType_qname) ||
1949		fault_qname == (&wsnt_InvalidTopicExpressionFault_qname))
1950		{
1951	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_INVALIDTOPICEXPRESSIONFAULT;
1952		}
1953	0	else if(fault_qname == (&wsnt_TopicNotSupportedFaultType_qname) ||
1954		fault_qname == (&wsnt_TopicNotSupportedFault_qname))
1955		{
1956	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_TOPICNOTSUPPORTEDFAULT;
1957		}
1958		else
1959		{
1960	0	*fault_type = COUNTERPORTTYPE_SUBSCRIBE_UNKNOWN_FAULT;
1961		}
1962		}
1963	0	}
1964		/* CounterPortType_l_Subscribe_deserialize_fault() */
1965
1966		/**
1967		* Nonblocking operation response handling
1968		* @ingroup CounterPortType_Subscribe_operation
1969		* Begin parsing the request for the <code>Subscribe</code> operation begun
1970		* by an earlier call to
1971		* CounterPortType_Subscribe_register_request() or
1972		* CounterPortType_Subscribe_epr_register_request(). Once the response has been parsed.
1973		* the @a callback function will be called to pass the result of the operation
1974		* to the application.
1975		*
1976		* @param client_handle
1977		* The @link #CounterService_client_handle_t client handle @endlink which
1978		* contains the state related to processing this operation.
1979		* @param callback
1980		* Callback function which will be called once the response has been
1981		* processed.
1982		* @param callback_arg
1983		* Application-specific pointer which will be passed to the callback.
1984		*/
1985		globus_result_t
1986		CounterPortType_Subscribe_register_response(
1987		CounterService_client_handle_t client_handle,
1988		CounterPortType_Subscribe_response_callback_func_t callback,
1989		void * callback_arg)
1990	0	{
1991	0	return globus_soap_client_register_response(
1992		client_handle,
1993		(globus_soap_client_response_callback_func_t) callback,
1994		callback_arg);
1995		}
1996
1997		/**
1998		* Nonblocking operation invocation with EPR
1999		* @ingroup CounterPortType_Subscribe_operation
2000		*
2001		* Begin processing a request for the Subscribe operation. The operation will
2002		* sent to the service named by the @a epr and after the response is received,
2003		* the @a callback function will be invoked.
2004		*
2005		* @param handle
2006		* The @link #CounterService_client_handle_t client handle @endlink which
2007		* contains the state related to processing this operation.
2008		* @param epr
2009		* Endpoint Reference of the service and resource which will process
2010		* the operation.
2011		* @param input
2012		* Input parameter to the operation.
2013		* @param callback
2014		* Callback function which will be called once the operation has been
2015		* processed.
2016		* @param callback_arg
2017		* Application-specific pointer which will be passed to the callback.
2018		*/
2019		globus_result_t
2020		CounterPortType_Subscribe_epr_register(
2021		CounterService_client_handle_t handle,
2022		const wsa_EndpointReferenceType * epr,
2023		const wsnt_SubscribeType * input,
2024		CounterPortType_Subscribe_response_callback_func_t callback,
2025		void * callback_arg)
2026	0	{
2027		globus_result_t result;
2028
2029	0	result = globus_soap_client_handle_attr_set(
2030		handle,
2031		WSADDR_EPR_KEY,
2032		wsa_EndpointReferenceType_info.copy,
2033		wsa_EndpointReferenceType_info.destroy,
2034		(void *) epr);
2035
2036	0	if (result != GLOBUS_SUCCESS)
2037		{
2038	0	goto out;
2039		}
2040
2041	0	result = globus_soap_client_operation_register(
2042		handle,
2043		epr->Address.base_value,
2044		&CounterPortType_l_Subscribe_operation,
2045		(void *) input,
2046		(globus_soap_client_response_callback_func_t) callback,
2047		callback_arg);
2048	0	out:
2049	0	return result;
2050		}
2051
2052		/**
2053		* Nonblocking operation invocation
2054		* @ingroup CounterPortType_Subscribe_operation
2055		*
2056		* Begin processing a request for the Subscribe operation. The operation will
2057		* sent to the service located at @a endpoint and after the response is
2058		* received, the @a callback function will be invoked.
2059		*
2060		* @param handle
2061		* The @link #CounterService_client_handle_t client handle @endlink which
2062		* contains the state related to processing this operation.
2063		* @param endpoint
2064		* URI of the service endpoint to send the request to.
2065		* @param input
2066		* Input parameter to the operation.
2067		* @param callback
2068		* Callback function which will be called once the operation has been
2069		* processed.
2070		* @param callback_arg
2071		* Application-specific pointer which will be passed to the callback.
2072		*/
2073		globus_result_t
2074		CounterPortType_Subscribe_register(
2075		CounterService_client_handle_t handle,
2076		const char * endpoint,
2077		const wsnt_SubscribeType * input,
2078		CounterPortType_Subscribe_response_callback_func_t callback,
2079		void * callback_arg)
2080	0	{
2081	0	return globus_soap_client_operation_register(
2082		handle,
2083		endpoint,
2084		&CounterPortType_l_Subscribe_operation,
2085		(void *) input,
2086		(globus_soap_client_response_callback_func_t) callback,
2087		callback_arg);
2088		}
2089
2090
2091
2092		/**
2093		* Blocking operation invocation with EPR
2094		* @ingroup CounterPortType_Subscribe_operation
2095		*
2096		* Request that an the Subscribe operation be invoked by the service and
2097		* resource named by the @a epr parameter.
2098
2099		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2100		* @a output parameter will be set to the result of the operation.
2101		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2102		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2103		* error occurred, and the result's error type should be checked.
2104
2105		*
2106		* @param handle
2107		* The @link #CounterService_client_handle_t client handle @endlink which
2108		* contains the state related to processing this operation.
2109		* @param epr
2110		* Endpoint Reference of the service and resource which will process
2111		* the operation.
2112		* @param input
2113		* Input parameter to the operation.
2114
2115		* @param output
2116		* The output of the operation, if the operation succeeded.
2117		* @param fault_type
2118		* The type of fault sent as a result of the operation, if the operation
2119		* failed. If the operation succeeded, this will be NULL.
2120		* @param fault
2121		* The fault element which was received, if the operation failed.
2122		* If the operation succeeded, this will be NULL.
2123
2124		*/
2125		globus_result_t
2126		CounterPortType_Subscribe_epr(
2127		CounterService_client_handle_t handle,
2128		const wsa_EndpointReferenceType * epr,
2129		const wsnt_SubscribeType * input,
2130		wsnt_SubscribeResponseType * * output,
2131		CounterPortType_Subscribe_fault_t * fault_type,
2132		xsd_any * * fault)
2133	11	{
2134		globus_result_t result;
2135
2136	11	result = globus_soap_client_handle_attr_set(
2137		handle,
2138		WSADDR_EPR_KEY,
2139		wsa_EndpointReferenceType_info.copy,
2140		wsa_EndpointReferenceType_info.destroy,
2141		(void *) epr);
2142
2143	11	if (result != GLOBUS_SUCCESS)
2144		{
2145	0	goto out;
2146		}
2147	11	result = globus_soap_client_operation(
2148		handle,
2149		epr->Address.base_value,
2150		&CounterPortType_l_Subscribe_operation,
2151		(void *) input,
2152
2153		(void **) output,
2154		(int *) fault_type,
2155		fault
2156		);
2157	11	out:
2158	11	return result;
2159		}
2160
2161		/**
2162		* Blocking operation invocation
2163		* @ingroup CounterPortType_Subscribe_operation
2164		*
2165		* Request that an the Subscribe operation be invoked by the service at
2166		* @a endpoint.
2167
2168		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2169		* @a output parameter will be set to the result of the operation.
2170		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2171		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2172		* error occurred, and the result's error type should be checked.
2173
2174		*
2175		* @param handle
2176		* The @link #CounterService_client_handle_t client handle @endlink which
2177		* contains the state related to processing this operation.
2178		* @param endpoint
2179		* URI of the service endpoint to send the request to.
2180		* @param input
2181		* Input parameter to the operation.
2182
2183		* @param output
2184		* The output of the operation, if the operation succeeded.
2185		* @param fault_type
2186		* The type of fault sent as a result of the operation, if the operation
2187		* failed. If the operation succeeded, this will be NULL.
2188		* @param fault
2189		* The fault element which was received, if the operation failed.
2190		* If the operation succeeded, this will be NULL.
2191
2192		*/
2193		globus_result_t
2194		CounterPortType_Subscribe(
2195		CounterService_client_handle_t handle,
2196		const char * endpoint,
2197		const wsnt_SubscribeType * input,
2198		wsnt_SubscribeResponseType * * output,
2199		CounterPortType_Subscribe_fault_t * fault_type,
2200		xsd_any * * fault)
2201	0	{
2202	0	return globus_soap_client_operation(
2203		handle,
2204		endpoint,
2205		&CounterPortType_l_Subscribe_operation,
2206		(void *) input,
2207
2208		(void *) output,
2209		(int *) fault_type,
2210		fault
2211		);
2212		}
2213
2214
2215		/**
2216		* Nonblocking operation request with EPR
2217		* @ingroup CounterPortType_GetMultipleResourceProperties_operation
2218		* Begin sending a request for the <code>GetMultipleResourceProperties</code> operation on a
2219		* resource handled by the service named by the @a epr. When the operation
2220		* request has been sent, the @a callback function will be invoked.
2221		*
2222		* @param client_handle
2223		* The @link #CounterService_client_handle_t client handle @endlink which
2224		* contains the state related to processing this operation.
2225		* @param epr
2226		* Endpoint Reference of the service and resource which will process
2227		* the operation.
2228		* @param input
2229		* Input parameter to the operation.
2230		* @param callback
2231		* Callback function which will be called once the request has been
2232		* sent
2233		* @param callback_arg
2234		* Application-specific pointer which will be passed to the callback.
2235		*/
2236		globus_result_t
2237		CounterPortType_GetMultipleResourceProperties_epr_register_request(
2238		CounterService_client_handle_t client_handle,
2239		const wsa_EndpointReferenceType * epr,
2240		const wsrp_GetMultipleResourcePropertiesType * input,
2241		CounterPortType_GetMultipleResourceProperties_request_callback_func_t callback,
2242		void * callback_arg)
2243	0	{
2244	0	globus_result_t result = GLOBUS_SUCCESS;
2245
2246	0	globus_assert_string(epr, "NULL EndpointReference");
2247	0	globus_assert_string(epr->Address.base_value,
2248		"NULL EndpointReference Address");
2249
2250	0	result = globus_soap_client_handle_attr_set(
2251		client_handle,
2252		WSADDR_EPR_KEY,
2253		wsa_EndpointReferenceType_info.copy,
2254		wsa_EndpointReferenceType_info.destroy,
2255		(void *) epr);
2256
2257	0	if (result != GLOBUS_SUCCESS)
2258		{
2259	0	goto out;
2260		}
2261
2262	0	result = globus_soap_client_register_request(
2263		client_handle,
2264		epr->Address.base_value,
2265		&CounterPortType_l_GetMultipleResourceProperties_operation,
2266		(void *) input,
2267		callback,
2268		callback_arg);
2269
2270	0	out:
2271	0	return result;
2272		}
2273
2274		/**
2275		* Nonblocking operation request
2276		* @ingroup CounterPortType_GetMultipleResourceProperties_operation
2277		* Begin sending a request for the <code>GetMultipleResourceProperties</code> operation to
2278		* the service at @a endpoint. When the operation
2279		* request has been sent, the @a callback function will be invoked.
2280		* @param handle
2281		* The @link #CounterService_client_handle_t client handle @endlink which
2282		* contains the state related to processing this operation.
2283		* @param endpoint
2284		* URI of the service endpoint to send the request to.
2285		* @param input
2286		* Input parameter to the operation.
2287		* @param callback
2288		* Callback function which will be called once the request has been
2289		* sent
2290		* @param callback_arg
2291		* Application-specific pointer which will be passed to the callback.
2292		*/
2293		globus_result_t
2294		CounterPortType_GetMultipleResourceProperties_register_request(
2295		CounterService_client_handle_t client_handle,
2296		const char * endpoint,
2297		const wsrp_GetMultipleResourcePropertiesType * input,
2298		CounterPortType_GetMultipleResourceProperties_request_callback_func_t callback,
2299		void * callback_arg)
2300	0	{
2301	0	return globus_soap_client_register_request(
2302		client_handle,
2303		endpoint,
2304		&CounterPortType_l_GetMultipleResourceProperties_operation,
2305		(void *) input,
2306		callback,
2307		callback_arg);
2308		}
2309
2310
2311
2312		static
2313		void
2314		CounterPortType_l_GetMultipleResourceProperties_deserialize_fault(
2315		globus_soap_message_handle_t handle,
2316		const xsd_QName * fault_qname,
2317		int * fault_type)
2318	0	{
2319	0	*fault_type = COUNTERPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_NOFAULT;
2320
2321	0	if(fault_qname)
2322		{
2323	0	if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
2324		fault_qname == (&wsr_ResourceUnknownFault_qname))
2325		{
2326	0	*fault_type = COUNTERPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_RESOURCEUNKNOWNFAULT;
2327		}
2328	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
2329		fault_qname == (&wsr_ResourceUnavailableFault_qname))
2330		{
2331	0	*fault_type = COUNTERPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_RESOURCEUNAVAILABLEFAULT;
2332		}
2333	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
2334		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
2335		{
2336	0	*fault_type = COUNTERPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_INVALIDRESOURCEPROPERTYQNAMEFAULT;
2337		}
2338		else
2339		{
2340	0	*fault_type = COUNTERPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_UNKNOWN_FAULT;
2341		}
2342		}
2343	0	}
2344		/* CounterPortType_l_GetMultipleResourceProperties_deserialize_fault() */
2345
2346		/**
2347		* Nonblocking operation response handling
2348		* @ingroup CounterPortType_GetMultipleResourceProperties_operation
2349		* Begin parsing the request for the <code>GetMultipleResourceProperties</code> operation begun
2350		* by an earlier call to
2351		* CounterPortType_GetMultipleResourceProperties_register_request() or
2352		* CounterPortType_GetMultipleResourceProperties_epr_register_request(). Once the response has been parsed.
2353		* the @a callback function will be called to pass the result of the operation
2354		* to the application.
2355		*
2356		* @param client_handle
2357		* The @link #CounterService_client_handle_t client handle @endlink which
2358		* contains the state related to processing this operation.
2359		* @param callback
2360		* Callback function which will be called once the response has been
2361		* processed.
2362		* @param callback_arg
2363		* Application-specific pointer which will be passed to the callback.
2364		*/
2365		globus_result_t
2366		CounterPortType_GetMultipleResourceProperties_register_response(
2367		CounterService_client_handle_t client_handle,
2368		CounterPortType_GetMultipleResourceProperties_response_callback_func_t callback,
2369		void * callback_arg)
2370	0	{
2371	0	return globus_soap_client_register_response(
2372		client_handle,
2373		(globus_soap_client_response_callback_func_t) callback,
2374		callback_arg);
2375		}
2376
2377		/**
2378		* Nonblocking operation invocation with EPR
2379		* @ingroup CounterPortType_GetMultipleResourceProperties_operation
2380		*
2381		* Begin processing a request for the GetMultipleResourceProperties operation. The operation will
2382		* sent to the service named by the @a epr and after the response is received,
2383		* the @a callback function will be invoked.
2384		*
2385		* @param handle
2386		* The @link #CounterService_client_handle_t client handle @endlink which
2387		* contains the state related to processing this operation.
2388		* @param epr
2389		* Endpoint Reference of the service and resource which will process
2390		* the operation.
2391		* @param input
2392		* Input parameter to the operation.
2393		* @param callback
2394		* Callback function which will be called once the operation has been
2395		* processed.
2396		* @param callback_arg
2397		* Application-specific pointer which will be passed to the callback.
2398		*/
2399		globus_result_t
2400		CounterPortType_GetMultipleResourceProperties_epr_register(
2401		CounterService_client_handle_t handle,
2402		const wsa_EndpointReferenceType * epr,
2403		const wsrp_GetMultipleResourcePropertiesType * input,
2404		CounterPortType_GetMultipleResourceProperties_response_callback_func_t callback,
2405		void * callback_arg)
2406	0	{
2407		globus_result_t result;
2408
2409	0	result = globus_soap_client_handle_attr_set(
2410		handle,
2411		WSADDR_EPR_KEY,
2412		wsa_EndpointReferenceType_info.copy,
2413		wsa_EndpointReferenceType_info.destroy,
2414		(void *) epr);
2415
2416	0	if (result != GLOBUS_SUCCESS)
2417		{
2418	0	goto out;
2419		}
2420
2421	0	result = globus_soap_client_operation_register(
2422		handle,
2423		epr->Address.base_value,
2424		&CounterPortType_l_GetMultipleResourceProperties_operation,
2425		(void *) input,
2426		(globus_soap_client_response_callback_func_t) callback,
2427		callback_arg);
2428	0	out:
2429	0	return result;
2430		}
2431
2432		/**
2433		* Nonblocking operation invocation
2434		* @ingroup CounterPortType_GetMultipleResourceProperties_operation
2435		*
2436		* Begin processing a request for the GetMultipleResourceProperties operation. The operation will
2437		* sent to the service located at @a endpoint and after the response is
2438		* received, the @a callback function will be invoked.
2439		*
2440		* @param handle
2441		* The @link #CounterService_client_handle_t client handle @endlink which
2442		* contains the state related to processing this operation.
2443		* @param endpoint
2444		* URI of the service endpoint to send the request to.
2445		* @param input
2446		* Input parameter to the operation.
2447		* @param callback
2448		* Callback function which will be called once the operation has been
2449		* processed.
2450		* @param callback_arg
2451		* Application-specific pointer which will be passed to the callback.
2452		*/
2453		globus_result_t
2454		CounterPortType_GetMultipleResourceProperties_register(
2455		CounterService_client_handle_t handle,
2456		const char * endpoint,
2457		const wsrp_GetMultipleResourcePropertiesType * input,
2458		CounterPortType_GetMultipleResourceProperties_response_callback_func_t callback,
2459		void * callback_arg)
2460	0	{
2461	0	return globus_soap_client_operation_register(
2462		handle,
2463		endpoint,
2464		&CounterPortType_l_GetMultipleResourceProperties_operation,
2465		(void *) input,
2466		(globus_soap_client_response_callback_func_t) callback,
2467		callback_arg);
2468		}
2469
2470
2471
2472		/**
2473		* Blocking operation invocation with EPR
2474		* @ingroup CounterPortType_GetMultipleResourceProperties_operation
2475		*
2476		* Request that an the GetMultipleResourceProperties operation be invoked by the service and
2477		* resource named by the @a epr parameter.
2478
2479		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2480		* @a output parameter will be set to the result of the operation.
2481		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2482		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2483		* error occurred, and the result's error type should be checked.
2484
2485		*
2486		* @param handle
2487		* The @link #CounterService_client_handle_t client handle @endlink which
2488		* contains the state related to processing this operation.
2489		* @param epr
2490		* Endpoint Reference of the service and resource which will process
2491		* the operation.
2492		* @param input
2493		* Input parameter to the operation.
2494
2495		* @param output
2496		* The output of the operation, if the operation succeeded.
2497		* @param fault_type
2498		* The type of fault sent as a result of the operation, if the operation
2499		* failed. If the operation succeeded, this will be NULL.
2500		* @param fault
2501		* The fault element which was received, if the operation failed.
2502		* If the operation succeeded, this will be NULL.
2503
2504		*/
2505		globus_result_t
2506		CounterPortType_GetMultipleResourceProperties_epr(
2507		CounterService_client_handle_t handle,
2508		const wsa_EndpointReferenceType * epr,
2509		const wsrp_GetMultipleResourcePropertiesType * input,
2510		wsrp_GetMultipleResourcePropertiesResponseType * * output,
2511		CounterPortType_GetMultipleResourceProperties_fault_t * fault_type,
2512		xsd_any * * fault)
2513	0	{
2514		globus_result_t result;
2515
2516	0	result = globus_soap_client_handle_attr_set(
2517		handle,
2518		WSADDR_EPR_KEY,
2519		wsa_EndpointReferenceType_info.copy,
2520		wsa_EndpointReferenceType_info.destroy,
2521		(void *) epr);
2522
2523	0	if (result != GLOBUS_SUCCESS)
2524		{
2525	0	goto out;
2526		}
2527	0	result = globus_soap_client_operation(
2528		handle,
2529		epr->Address.base_value,
2530		&CounterPortType_l_GetMultipleResourceProperties_operation,
2531		(void *) input,
2532
2533		(void **) output,
2534		(int *) fault_type,
2535		fault
2536		);
2537	0	out:
2538	0	return result;
2539		}
2540
2541		/**
2542		* Blocking operation invocation
2543		* @ingroup CounterPortType_GetMultipleResourceProperties_operation
2544		*
2545		* Request that an the GetMultipleResourceProperties operation be invoked by the service at
2546		* @a endpoint.
2547
2548		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2549		* @a output parameter will be set to the result of the operation.
2550		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2551		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2552		* error occurred, and the result's error type should be checked.
2553
2554		*
2555		* @param handle
2556		* The @link #CounterService_client_handle_t client handle @endlink which
2557		* contains the state related to processing this operation.
2558		* @param endpoint
2559		* URI of the service endpoint to send the request to.
2560		* @param input
2561		* Input parameter to the operation.
2562
2563		* @param output
2564		* The output of the operation, if the operation succeeded.
2565		* @param fault_type
2566		* The type of fault sent as a result of the operation, if the operation
2567		* failed. If the operation succeeded, this will be NULL.
2568		* @param fault
2569		* The fault element which was received, if the operation failed.
2570		* If the operation succeeded, this will be NULL.
2571
2572		*/
2573		globus_result_t
2574		CounterPortType_GetMultipleResourceProperties(
2575		CounterService_client_handle_t handle,
2576		const char * endpoint,
2577		const wsrp_GetMultipleResourcePropertiesType * input,
2578		wsrp_GetMultipleResourcePropertiesResponseType * * output,
2579		CounterPortType_GetMultipleResourceProperties_fault_t * fault_type,
2580		xsd_any * * fault)
2581	0	{
2582	0	return globus_soap_client_operation(
2583		handle,
2584		endpoint,
2585		&CounterPortType_l_GetMultipleResourceProperties_operation,
2586		(void *) input,
2587
2588		(void *) output,
2589		(int *) fault_type,
2590		fault
2591		);
2592		}
2593
2594
2595		/**
2596		* Nonblocking operation request with EPR
2597		* @ingroup CounterPortType_QueryResourceProperties_operation
2598		* Begin sending a request for the <code>QueryResourceProperties</code> operation on a
2599		* resource handled by the service named by the @a epr. When the operation
2600		* request has been sent, the @a callback function will be invoked.
2601		*
2602		* @param client_handle
2603		* The @link #CounterService_client_handle_t client handle @endlink which
2604		* contains the state related to processing this operation.
2605		* @param epr
2606		* Endpoint Reference of the service and resource which will process
2607		* the operation.
2608		* @param input
2609		* Input parameter to the operation.
2610		* @param callback
2611		* Callback function which will be called once the request has been
2612		* sent
2613		* @param callback_arg
2614		* Application-specific pointer which will be passed to the callback.
2615		*/
2616		globus_result_t
2617		CounterPortType_QueryResourceProperties_epr_register_request(
2618		CounterService_client_handle_t client_handle,
2619		const wsa_EndpointReferenceType * epr,
2620		const wsrp_QueryResourcePropertiesType * input,
2621		CounterPortType_QueryResourceProperties_request_callback_func_t callback,
2622		void * callback_arg)
2623	0	{
2624	0	globus_result_t result = GLOBUS_SUCCESS;
2625
2626	0	globus_assert_string(epr, "NULL EndpointReference");
2627	0	globus_assert_string(epr->Address.base_value,
2628		"NULL EndpointReference Address");
2629
2630	0	result = globus_soap_client_handle_attr_set(
2631		client_handle,
2632		WSADDR_EPR_KEY,
2633		wsa_EndpointReferenceType_info.copy,
2634		wsa_EndpointReferenceType_info.destroy,
2635		(void *) epr);
2636
2637	0	if (result != GLOBUS_SUCCESS)
2638		{
2639	0	goto out;
2640		}
2641
2642	0	result = globus_soap_client_register_request(
2643		client_handle,
2644		epr->Address.base_value,
2645		&CounterPortType_l_QueryResourceProperties_operation,
2646		(void *) input,
2647		callback,
2648		callback_arg);
2649
2650	0	out:
2651	0	return result;
2652		}
2653
2654		/**
2655		* Nonblocking operation request
2656		* @ingroup CounterPortType_QueryResourceProperties_operation
2657		* Begin sending a request for the <code>QueryResourceProperties</code> operation to
2658		* the service at @a endpoint. When the operation
2659		* request has been sent, the @a callback function will be invoked.
2660		* @param handle
2661		* The @link #CounterService_client_handle_t client handle @endlink which
2662		* contains the state related to processing this operation.
2663		* @param endpoint
2664		* URI of the service endpoint to send the request to.
2665		* @param input
2666		* Input parameter to the operation.
2667		* @param callback
2668		* Callback function which will be called once the request has been
2669		* sent
2670		* @param callback_arg
2671		* Application-specific pointer which will be passed to the callback.
2672		*/
2673		globus_result_t
2674		CounterPortType_QueryResourceProperties_register_request(
2675		CounterService_client_handle_t client_handle,
2676		const char * endpoint,
2677		const wsrp_QueryResourcePropertiesType * input,
2678		CounterPortType_QueryResourceProperties_request_callback_func_t callback,
2679		void * callback_arg)
2680	0	{
2681	0	return globus_soap_client_register_request(
2682		client_handle,
2683		endpoint,
2684		&CounterPortType_l_QueryResourceProperties_operation,
2685		(void *) input,
2686		callback,
2687		callback_arg);
2688		}
2689
2690
2691
2692		static
2693		void
2694		CounterPortType_l_QueryResourceProperties_deserialize_fault(
2695		globus_soap_message_handle_t handle,
2696		const xsd_QName * fault_qname,
2697		int * fault_type)
2698	0	{
2699	0	*fault_type = COUNTERPORTTYPE_QUERYRESOURCEPROPERTIES_NOFAULT;
2700
2701	0	if(fault_qname)
2702		{
2703	0	if(fault_qname == (&wsrp_UnknownQueryExpressionDialectFaultType_qname) ||
2704		fault_qname == (&wsrp_UnknownQueryExpressionDialectFault_qname))
2705		{
2706	0	*fault_type = COUNTERPORTTYPE_QUERYRESOURCEPROPERTIES_UNKNOWNQUERYEXPRESSIONDIALECTFAULT;
2707		}
2708	0	else if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
2709		fault_qname == (&wsr_ResourceUnknownFault_qname))
2710		{
2711	0	*fault_type = COUNTERPORTTYPE_QUERYRESOURCEPROPERTIES_RESOURCEUNKNOWNFAULT;
2712		}
2713	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
2714		fault_qname == (&wsr_ResourceUnavailableFault_qname))
2715		{
2716	0	*fault_type = COUNTERPORTTYPE_QUERYRESOURCEPROPERTIES_RESOURCEUNAVAILABLEFAULT;
2717		}
2718	0	else if(fault_qname == (&wsrp_QueryEvaluationErrorFaultType_qname) ||
2719		fault_qname == (&wsrp_QueryEvaluationErrorFault_qname))
2720		{
2721	0	*fault_type = COUNTERPORTTYPE_QUERYRESOURCEPROPERTIES_QUERYEVALUATIONERRORFAULT;
2722		}
2723	0	else if(fault_qname == (&wsrp_InvalidQueryExpressionFaultType_qname) ||
2724		fault_qname == (&wsrp_InvalidQueryExpressionFault_qname))
2725		{
2726	0	*fault_type = COUNTERPORTTYPE_QUERYRESOURCEPROPERTIES_INVALIDQUERYEXPRESSIONFAULT;
2727		}
2728	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
2729		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
2730		{
2731	0	*fault_type = COUNTERPORTTYPE_QUERYRESOURCEPROPERTIES_INVALIDRESOURCEPROPERTYQNAMEFAULT;
2732		}
2733		else
2734		{
2735	0	*fault_type = COUNTERPORTTYPE_QUERYRESOURCEPROPERTIES_UNKNOWN_FAULT;
2736		}
2737		}
2738	0	}
2739		/* CounterPortType_l_QueryResourceProperties_deserialize_fault() */
2740
2741		/**
2742		* Nonblocking operation response handling
2743		* @ingroup CounterPortType_QueryResourceProperties_operation
2744		* Begin parsing the request for the <code>QueryResourceProperties</code> operation begun
2745		* by an earlier call to
2746		* CounterPortType_QueryResourceProperties_register_request() or
2747		* CounterPortType_QueryResourceProperties_epr_register_request(). Once the response has been parsed.
2748		* the @a callback function will be called to pass the result of the operation
2749		* to the application.
2750		*
2751		* @param client_handle
2752		* The @link #CounterService_client_handle_t client handle @endlink which
2753		* contains the state related to processing this operation.
2754		* @param callback
2755		* Callback function which will be called once the response has been
2756		* processed.
2757		* @param callback_arg
2758		* Application-specific pointer which will be passed to the callback.
2759		*/
2760		globus_result_t
2761		CounterPortType_QueryResourceProperties_register_response(
2762		CounterService_client_handle_t client_handle,
2763		CounterPortType_QueryResourceProperties_response_callback_func_t callback,
2764		void * callback_arg)
2765	0	{
2766	0	return globus_soap_client_register_response(
2767		client_handle,
2768		(globus_soap_client_response_callback_func_t) callback,
2769		callback_arg);
2770		}
2771
2772		/**
2773		* Nonblocking operation invocation with EPR
2774		* @ingroup CounterPortType_QueryResourceProperties_operation
2775		*
2776		* Begin processing a request for the QueryResourceProperties operation. The operation will
2777		* sent to the service named by the @a epr and after the response is received,
2778		* the @a callback function will be invoked.
2779		*
2780		* @param handle
2781		* The @link #CounterService_client_handle_t client handle @endlink which
2782		* contains the state related to processing this operation.
2783		* @param epr
2784		* Endpoint Reference of the service and resource which will process
2785		* the operation.
2786		* @param input
2787		* Input parameter to the operation.
2788		* @param callback
2789		* Callback function which will be called once the operation has been
2790		* processed.
2791		* @param callback_arg
2792		* Application-specific pointer which will be passed to the callback.
2793		*/
2794		globus_result_t
2795		CounterPortType_QueryResourceProperties_epr_register(
2796		CounterService_client_handle_t handle,
2797		const wsa_EndpointReferenceType * epr,
2798		const wsrp_QueryResourcePropertiesType * input,
2799		CounterPortType_QueryResourceProperties_response_callback_func_t callback,
2800		void * callback_arg)
2801	0	{
2802		globus_result_t result;
2803
2804	0	result = globus_soap_client_handle_attr_set(
2805		handle,
2806		WSADDR_EPR_KEY,
2807		wsa_EndpointReferenceType_info.copy,
2808		wsa_EndpointReferenceType_info.destroy,
2809		(void *) epr);
2810
2811	0	if (result != GLOBUS_SUCCESS)
2812		{
2813	0	goto out;
2814		}
2815
2816	0	result = globus_soap_client_operation_register(
2817		handle,
2818		epr->Address.base_value,
2819		&CounterPortType_l_QueryResourceProperties_operation,
2820		(void *) input,
2821		(globus_soap_client_response_callback_func_t) callback,
2822		callback_arg);
2823	0	out:
2824	0	return result;
2825		}
2826
2827		/**
2828		* Nonblocking operation invocation
2829		* @ingroup CounterPortType_QueryResourceProperties_operation
2830		*
2831		* Begin processing a request for the QueryResourceProperties operation. The operation will
2832		* sent to the service located at @a endpoint and after the response is
2833		* received, the @a callback function will be invoked.
2834		*
2835		* @param handle
2836		* The @link #CounterService_client_handle_t client handle @endlink which
2837		* contains the state related to processing this operation.
2838		* @param endpoint
2839		* URI of the service endpoint to send the request to.
2840		* @param input
2841		* Input parameter to the operation.
2842		* @param callback
2843		* Callback function which will be called once the operation has been
2844		* processed.
2845		* @param callback_arg
2846		* Application-specific pointer which will be passed to the callback.
2847		*/
2848		globus_result_t
2849		CounterPortType_QueryResourceProperties_register(
2850		CounterService_client_handle_t handle,
2851		const char * endpoint,
2852		const wsrp_QueryResourcePropertiesType * input,
2853		CounterPortType_QueryResourceProperties_response_callback_func_t callback,
2854		void * callback_arg)
2855	0	{
2856	0	return globus_soap_client_operation_register(
2857		handle,
2858		endpoint,
2859		&CounterPortType_l_QueryResourceProperties_operation,
2860		(void *) input,
2861		(globus_soap_client_response_callback_func_t) callback,
2862		callback_arg);
2863		}
2864
2865
2866
2867		/**
2868		* Blocking operation invocation with EPR
2869		* @ingroup CounterPortType_QueryResourceProperties_operation
2870		*
2871		* Request that an the QueryResourceProperties operation be invoked by the service and
2872		* resource named by the @a epr parameter.
2873
2874		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2875		* @a output parameter will be set to the result of the operation.
2876		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2877		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2878		* error occurred, and the result's error type should be checked.
2879
2880		*
2881		* @param handle
2882		* The @link #CounterService_client_handle_t client handle @endlink which
2883		* contains the state related to processing this operation.
2884		* @param epr
2885		* Endpoint Reference of the service and resource which will process
2886		* the operation.
2887		* @param input
2888		* Input parameter to the operation.
2889
2890		* @param output
2891		* The output of the operation, if the operation succeeded.
2892		* @param fault_type
2893		* The type of fault sent as a result of the operation, if the operation
2894		* failed. If the operation succeeded, this will be NULL.
2895		* @param fault
2896		* The fault element which was received, if the operation failed.
2897		* If the operation succeeded, this will be NULL.
2898
2899		*/
2900		globus_result_t
2901		CounterPortType_QueryResourceProperties_epr(
2902		CounterService_client_handle_t handle,
2903		const wsa_EndpointReferenceType * epr,
2904		const wsrp_QueryResourcePropertiesType * input,
2905		wsrp_QueryResourcePropertiesResponseType * * output,
2906		CounterPortType_QueryResourceProperties_fault_t * fault_type,
2907		xsd_any * * fault)
2908	0	{
2909		globus_result_t result;
2910
2911	0	result = globus_soap_client_handle_attr_set(
2912		handle,
2913		WSADDR_EPR_KEY,
2914		wsa_EndpointReferenceType_info.copy,
2915		wsa_EndpointReferenceType_info.destroy,
2916		(void *) epr);
2917
2918	0	if (result != GLOBUS_SUCCESS)
2919		{
2920	0	goto out;
2921		}
2922	0	result = globus_soap_client_operation(
2923		handle,
2924		epr->Address.base_value,
2925		&CounterPortType_l_QueryResourceProperties_operation,
2926		(void *) input,
2927
2928		(void **) output,
2929		(int *) fault_type,
2930		fault
2931		);
2932	0	out:
2933	0	return result;
2934		}
2935
2936		/**
2937		* Blocking operation invocation
2938		* @ingroup CounterPortType_QueryResourceProperties_operation
2939		*
2940		* Request that an the QueryResourceProperties operation be invoked by the service at
2941		* @a endpoint.
2942
2943		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2944		* @a output parameter will be set to the result of the operation.
2945		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2946		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2947		* error occurred, and the result's error type should be checked.
2948
2949		*
2950		* @param handle
2951		* The @link #CounterService_client_handle_t client handle @endlink which
2952		* contains the state related to processing this operation.
2953		* @param endpoint
2954		* URI of the service endpoint to send the request to.
2955		* @param input
2956		* Input parameter to the operation.
2957
2958		* @param output
2959		* The output of the operation, if the operation succeeded.
2960		* @param fault_type
2961		* The type of fault sent as a result of the operation, if the operation
2962		* failed. If the operation succeeded, this will be NULL.
2963		* @param fault
2964		* The fault element which was received, if the operation failed.
2965		* If the operation succeeded, this will be NULL.
2966
2967		*/
2968		globus_result_t
2969		CounterPortType_QueryResourceProperties(
2970		CounterService_client_handle_t handle,
2971		const char * endpoint,
2972		const wsrp_QueryResourcePropertiesType * input,
2973		wsrp_QueryResourcePropertiesResponseType * * output,
2974		CounterPortType_QueryResourceProperties_fault_t * fault_type,
2975		xsd_any * * fault)
2976	0	{
2977	0	return globus_soap_client_operation(
2978		handle,
2979		endpoint,
2980		&CounterPortType_l_QueryResourceProperties_operation,
2981		(void *) input,
2982
2983		(void *) output,
2984		(int *) fault_type,
2985		fault
2986		);
2987		}
2988
2989
2990		/**
2991		* Nonblocking operation request with EPR
2992		* @ingroup CounterPortType_GetResourceProperty_operation
2993		* Begin sending a request for the <code>GetResourceProperty</code> operation on a
2994		* resource handled by the service named by the @a epr. When the operation
2995		* request has been sent, the @a callback function will be invoked.
2996		*
2997		* @param client_handle
2998		* The @link #CounterService_client_handle_t client handle @endlink which
2999		* contains the state related to processing this operation.
3000		* @param epr
3001		* Endpoint Reference of the service and resource which will process
3002		* the operation.
3003		* @param input
3004		* Input parameter to the operation.
3005		* @param callback
3006		* Callback function which will be called once the request has been
3007		* sent
3008		* @param callback_arg
3009		* Application-specific pointer which will be passed to the callback.
3010		*/
3011		globus_result_t
3012		CounterPortType_GetResourceProperty_epr_register_request(
3013		CounterService_client_handle_t client_handle,
3014		const wsa_EndpointReferenceType * epr,
3015		const xsd_QName * input,
3016		CounterPortType_GetResourceProperty_request_callback_func_t callback,
3017		void * callback_arg)
3018	0	{
3019	0	globus_result_t result = GLOBUS_SUCCESS;
3020
3021	0	globus_assert_string(epr, "NULL EndpointReference");
3022	0	globus_assert_string(epr->Address.base_value,
3023		"NULL EndpointReference Address");
3024
3025	0	result = globus_soap_client_handle_attr_set(
3026		client_handle,
3027		WSADDR_EPR_KEY,
3028		wsa_EndpointReferenceType_info.copy,
3029		wsa_EndpointReferenceType_info.destroy,
3030		(void *) epr);
3031
3032	0	if (result != GLOBUS_SUCCESS)
3033		{
3034	0	goto out;
3035		}
3036
3037	0	result = globus_soap_client_register_request(
3038		client_handle,
3039		epr->Address.base_value,
3040		&CounterPortType_l_GetResourceProperty_operation,
3041		(void *) input,
3042		callback,
3043		callback_arg);
3044
3045	0	out:
3046	0	return result;
3047		}
3048
3049		/**
3050		* Nonblocking operation request
3051		* @ingroup CounterPortType_GetResourceProperty_operation
3052		* Begin sending a request for the <code>GetResourceProperty</code> operation to
3053		* the service at @a endpoint. When the operation
3054		* request has been sent, the @a callback function will be invoked.
3055		* @param handle
3056		* The @link #CounterService_client_handle_t client handle @endlink which
3057		* contains the state related to processing this operation.
3058		* @param endpoint
3059		* URI of the service endpoint to send the request to.
3060		* @param input
3061		* Input parameter to the operation.
3062		* @param callback
3063		* Callback function which will be called once the request has been
3064		* sent
3065		* @param callback_arg
3066		* Application-specific pointer which will be passed to the callback.
3067		*/
3068		globus_result_t
3069		CounterPortType_GetResourceProperty_register_request(
3070		CounterService_client_handle_t client_handle,
3071		const char * endpoint,
3072		const xsd_QName * input,
3073		CounterPortType_GetResourceProperty_request_callback_func_t callback,
3074		void * callback_arg)
3075	0	{
3076	0	return globus_soap_client_register_request(
3077		client_handle,
3078		endpoint,
3079		&CounterPortType_l_GetResourceProperty_operation,
3080		(void *) input,
3081		callback,
3082		callback_arg);
3083		}
3084
3085
3086
3087		static
3088		void
3089		CounterPortType_l_GetResourceProperty_deserialize_fault(
3090		globus_soap_message_handle_t handle,
3091		const xsd_QName * fault_qname,
3092		int * fault_type)
3093	0	{
3094	0	*fault_type = COUNTERPORTTYPE_GETRESOURCEPROPERTY_NOFAULT;
3095
3096	0	if(fault_qname)
3097		{
3098	0	if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
3099		fault_qname == (&wsr_ResourceUnknownFault_qname))
3100		{
3101	0	*fault_type = COUNTERPORTTYPE_GETRESOURCEPROPERTY_RESOURCEUNKNOWNFAULT;
3102		}
3103	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
3104		fault_qname == (&wsr_ResourceUnavailableFault_qname))
3105		{
3106	0	*fault_type = COUNTERPORTTYPE_GETRESOURCEPROPERTY_RESOURCEUNAVAILABLEFAULT;
3107		}
3108	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
3109		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
3110		{
3111	0	*fault_type = COUNTERPORTTYPE_GETRESOURCEPROPERTY_INVALIDRESOURCEPROPERTYQNAMEFAULT;
3112		}
3113		else
3114		{
3115	0	*fault_type = COUNTERPORTTYPE_GETRESOURCEPROPERTY_UNKNOWN_FAULT;
3116		}
3117		}
3118	0	}
3119		/* CounterPortType_l_GetResourceProperty_deserialize_fault() */
3120
3121		/**
3122		* Nonblocking operation response handling
3123		* @ingroup CounterPortType_GetResourceProperty_operation
3124		* Begin parsing the request for the <code>GetResourceProperty</code> operation begun
3125		* by an earlier call to
3126		* CounterPortType_GetResourceProperty_register_request() or
3127		* CounterPortType_GetResourceProperty_epr_register_request(). Once the response has been parsed.
3128		* the @a callback function will be called to pass the result of the operation
3129		* to the application.
3130		*
3131		* @param client_handle
3132		* The @link #CounterService_client_handle_t client handle @endlink which
3133		* contains the state related to processing this operation.
3134		* @param callback
3135		* Callback function which will be called once the response has been
3136		* processed.
3137		* @param callback_arg
3138		* Application-specific pointer which will be passed to the callback.
3139		*/
3140		globus_result_t
3141		CounterPortType_GetResourceProperty_register_response(
3142		CounterService_client_handle_t client_handle,
3143		CounterPortType_GetResourceProperty_response_callback_func_t callback,
3144		void * callback_arg)
3145	0	{
3146	0	return globus_soap_client_register_response(
3147		client_handle,
3148		(globus_soap_client_response_callback_func_t) callback,
3149		callback_arg);
3150		}
3151
3152		/**
3153		* Nonblocking operation invocation with EPR
3154		* @ingroup CounterPortType_GetResourceProperty_operation
3155		*
3156		* Begin processing a request for the GetResourceProperty operation. The operation will
3157		* sent to the service named by the @a epr and after the response is received,
3158		* the @a callback function will be invoked.
3159		*
3160		* @param handle
3161		* The @link #CounterService_client_handle_t client handle @endlink which
3162		* contains the state related to processing this operation.
3163		* @param epr
3164		* Endpoint Reference of the service and resource which will process
3165		* the operation.
3166		* @param input
3167		* Input parameter to the operation.
3168		* @param callback
3169		* Callback function which will be called once the operation has been
3170		* processed.
3171		* @param callback_arg
3172		* Application-specific pointer which will be passed to the callback.
3173		*/
3174		globus_result_t
3175		CounterPortType_GetResourceProperty_epr_register(
3176		CounterService_client_handle_t handle,
3177		const wsa_EndpointReferenceType * epr,
3178		const xsd_QName * input,
3179		CounterPortType_GetResourceProperty_response_callback_func_t callback,
3180		void * callback_arg)
3181	0	{
3182		globus_result_t result;
3183
3184	0	result = globus_soap_client_handle_attr_set(
3185		handle,
3186		WSADDR_EPR_KEY,
3187		wsa_EndpointReferenceType_info.copy,
3188		wsa_EndpointReferenceType_info.destroy,
3189		(void *) epr);
3190
3191	0	if (result != GLOBUS_SUCCESS)
3192		{
3193	0	goto out;
3194		}
3195
3196	0	result = globus_soap_client_operation_register(
3197		handle,
3198		epr->Address.base_value,
3199		&CounterPortType_l_GetResourceProperty_operation,
3200		(void *) input,
3201		(globus_soap_client_response_callback_func_t) callback,
3202		callback_arg);
3203	0	out:
3204	0	return result;
3205		}
3206
3207		/**
3208		* Nonblocking operation invocation
3209		* @ingroup CounterPortType_GetResourceProperty_operation
3210		*
3211		* Begin processing a request for the GetResourceProperty operation. The operation will
3212		* sent to the service located at @a endpoint and after the response is
3213		* received, the @a callback function will be invoked.
3214		*
3215		* @param handle
3216		* The @link #CounterService_client_handle_t client handle @endlink which
3217		* contains the state related to processing this operation.
3218		* @param endpoint
3219		* URI of the service endpoint to send the request to.
3220		* @param input
3221		* Input parameter to the operation.
3222		* @param callback
3223		* Callback function which will be called once the operation has been
3224		* processed.
3225		* @param callback_arg
3226		* Application-specific pointer which will be passed to the callback.
3227		*/
3228		globus_result_t
3229		CounterPortType_GetResourceProperty_register(
3230		CounterService_client_handle_t handle,
3231		const char * endpoint,
3232		const xsd_QName * input,
3233		CounterPortType_GetResourceProperty_response_callback_func_t callback,
3234		void * callback_arg)
3235	0	{
3236	0	return globus_soap_client_operation_register(
3237		handle,
3238		endpoint,
3239		&CounterPortType_l_GetResourceProperty_operation,
3240		(void *) input,
3241		(globus_soap_client_response_callback_func_t) callback,
3242		callback_arg);
3243		}
3244
3245
3246
3247		/**
3248		* Blocking operation invocation with EPR
3249		* @ingroup CounterPortType_GetResourceProperty_operation
3250		*
3251		* Request that an the GetResourceProperty operation be invoked by the service and
3252		* resource named by the @a epr parameter.
3253
3254		* If the result is <code>GLOBUS_SUCCESS</code>, then the
3255		* @a output parameter will be set to the result of the operation.
3256		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
3257		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
3258		* error occurred, and the result's error type should be checked.
3259
3260		*
3261		* @param handle
3262		* The @link #CounterService_client_handle_t client handle @endlink which
3263		* contains the state related to processing this operation.
3264		* @param epr
3265		* Endpoint Reference of the service and resource which will process
3266		* the operation.
3267		* @param input
3268		* Input parameter to the operation.
3269
3270		* @param output
3271		* The output of the operation, if the operation succeeded.
3272		* @param fault_type
3273		* The type of fault sent as a result of the operation, if the operation
3274		* failed. If the operation succeeded, this will be NULL.
3275		* @param fault
3276		* The fault element which was received, if the operation failed.
3277		* If the operation succeeded, this will be NULL.
3278
3279		*/
3280		globus_result_t
3281		CounterPortType_GetResourceProperty_epr(
3282		CounterService_client_handle_t handle,
3283		const wsa_EndpointReferenceType * epr,
3284		const xsd_QName * input,
3285		wsrp_GetResourcePropertyResponseType * * output,
3286		CounterPortType_GetResourceProperty_fault_t * fault_type,
3287		xsd_any * * fault)
3288	30	{
3289		globus_result_t result;
3290
3291	30	result = globus_soap_client_handle_attr_set(
3292		handle,
3293		WSADDR_EPR_KEY,
3294		wsa_EndpointReferenceType_info.copy,
3295		wsa_EndpointReferenceType_info.destroy,
3296		(void *) epr);
3297
3298	30	if (result != GLOBUS_SUCCESS)
3299		{
3300	0	goto out;
3301		}
3302	30	result = globus_soap_client_operation(
3303		handle,
3304		epr->Address.base_value,
3305		&CounterPortType_l_GetResourceProperty_operation,
3306		(void *) input,
3307
3308		(void **) output,
3309		(int *) fault_type,
3310		fault
3311		);
3312	30	out:
3313	30	return result;
3314		}
3315
3316		/**
3317		* Blocking operation invocation
3318		* @ingroup CounterPortType_GetResourceProperty_operation
3319		*
3320		* Request that an the GetResourceProperty operation be invoked by the service at
3321		* @a endpoint.
3322
3323		* If the result is <code>GLOBUS_SUCCESS</code>, then the
3324		* @a output parameter will be set to the result of the operation.
3325		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
3326		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
3327		* error occurred, and the result's error type should be checked.
3328
3329		*
3330		* @param handle
3331		* The @link #CounterService_client_handle_t client handle @endlink which
3332		* contains the state related to processing this operation.
3333		* @param endpoint
3334		* URI of the service endpoint to send the request to.
3335		* @param input
3336		* Input parameter to the operation.
3337
3338		* @param output
3339		* The output of the operation, if the operation succeeded.
3340		* @param fault_type
3341		* The type of fault sent as a result of the operation, if the operation
3342		* failed. If the operation succeeded, this will be NULL.
3343		* @param fault
3344		* The fault element which was received, if the operation failed.
3345		* If the operation succeeded, this will be NULL.
3346
3347		*/
3348		globus_result_t
3349		CounterPortType_GetResourceProperty(
3350		CounterService_client_handle_t handle,
3351		const char * endpoint,
3352		const xsd_QName * input,
3353		wsrp_GetResourcePropertyResponseType * * output,
3354		CounterPortType_GetResourceProperty_fault_t * fault_type,
3355		xsd_any * * fault)
3356	0	{
3357	0	return globus_soap_client_operation(
3358		handle,
3359		endpoint,
3360		&CounterPortType_l_GetResourceProperty_operation,
3361		(void *) input,
3362
3363		(void *) output,
3364		(int *) fault_type,
3365		fault
3366		);
3367		}
3368
3369
3370		/**
3371		* Nonblocking operation request with EPR
3372		* @ingroup CounterPortType_add_operation
3373		* Begin sending a request for the <code>add</code> operation on a
3374		* resource handled by the service named by the @a epr. When the operation
3375		* request has been sent, the @a callback function will be invoked.
3376		*
3377		* @param client_handle
3378		* The @link #CounterService_client_handle_t client handle @endlink which
3379		* contains the state related to processing this operation.
3380		* @param epr
3381		* Endpoint Reference of the service and resource which will process
3382		* the operation.
3383		* @param input
3384		* Input parameter to the operation.
3385		* @param callback
3386		* Callback function which will be called once the request has been
3387		* sent
3388		* @param callback_arg
3389		* Application-specific pointer which will be passed to the callback.
3390		*/
3391		globus_result_t
3392		CounterPortType_add_epr_register_request(
3393		CounterService_client_handle_t client_handle,
3394		const wsa_EndpointReferenceType * epr,
3395		const xsd_int * input,
3396		CounterPortType_add_request_callback_func_t callback,
3397		void * callback_arg)
3398	0	{
3399	0	globus_result_t result = GLOBUS_SUCCESS;
3400
3401	0	globus_assert_string(epr, "NULL EndpointReference");
3402	0	globus_assert_string(epr->Address.base_value,
3403		"NULL EndpointReference Address");
3404
3405	0	result = globus_soap_client_handle_attr_set(
3406		client_handle,
3407		WSADDR_EPR_KEY,
3408		wsa_EndpointReferenceType_info.copy,
3409		wsa_EndpointReferenceType_info.destroy,
3410		(void *) epr);
3411
3412	0	if (result != GLOBUS_SUCCESS)
3413		{
3414	0	goto out;
3415		}
3416
3417	0	result = globus_soap_client_register_request(
3418		client_handle,
3419		epr->Address.base_value,
3420		&CounterPortType_l_add_operation,
3421		(void *) input,
3422		callback,
3423		callback_arg);
3424
3425	0	out:
3426	0	return result;
3427		}
3428
3429		/**
3430		* Nonblocking operation request
3431		* @ingroup CounterPortType_add_operation
3432		* Begin sending a request for the <code>add</code> operation to
3433		* the service at @a endpoint. When the operation
3434		* request has been sent, the @a callback function will be invoked.
3435		* @param handle
3436		* The @link #CounterService_client_handle_t client handle @endlink which
3437		* contains the state related to processing this operation.
3438		* @param endpoint
3439		* URI of the service endpoint to send the request to.
3440		* @param input
3441		* Input parameter to the operation.
3442		* @param callback
3443		* Callback function which will be called once the request has been
3444		* sent
3445		* @param callback_arg
3446		* Application-specific pointer which will be passed to the callback.
3447		*/
3448		globus_result_t
3449		CounterPortType_add_register_request(
3450		CounterService_client_handle_t client_handle,
3451		const char * endpoint,
3452		const xsd_int * input,
3453		CounterPortType_add_request_callback_func_t callback,
3454		void * callback_arg)
3455	0	{
3456	0	return globus_soap_client_register_request(
3457		client_handle,
3458		endpoint,
3459		&CounterPortType_l_add_operation,
3460		(void *) input,
3461		callback,
3462		callback_arg);
3463		}
3464
3465
3466
3467		static
3468		void
3469		CounterPortType_l_add_deserialize_fault(
3470		globus_soap_message_handle_t handle,
3471		const xsd_QName * fault_qname,
3472		int * fault_type)
3473	0	{
3474	0	*fault_type = COUNTERPORTTYPE_ADD_NOFAULT;
3475
3476	0	if(fault_qname)
3477		{
3478
3479		{
3480	0	*fault_type = COUNTERPORTTYPE_ADD_UNKNOWN_FAULT;
3481		}
3482		}
3483	0	}
3484		/* CounterPortType_l_add_deserialize_fault() */
3485
3486		/**
3487		* Nonblocking operation response handling
3488		* @ingroup CounterPortType_add_operation
3489		* Begin parsing the request for the <code>add</code> operation begun
3490		* by an earlier call to
3491		* CounterPortType_add_register_request() or
3492		* CounterPortType_add_epr_register_request(). Once the response has been parsed.
3493		* the @a callback function will be called to pass the result of the operation
3494		* to the application.
3495		*
3496		* @param client_handle
3497		* The @link #CounterService_client_handle_t client handle @endlink which
3498		* contains the state related to processing this operation.
3499		* @param callback
3500		* Callback function which will be called once the response has been
3501		* processed.
3502		* @param callback_arg
3503		* Application-specific pointer which will be passed to the callback.
3504		*/
3505		globus_result_t
3506		CounterPortType_add_register_response(
3507		CounterService_client_handle_t client_handle,
3508		CounterPortType_add_response_callback_func_t callback,
3509		void * callback_arg)
3510	0	{
3511	0	return globus_soap_client_register_response(
3512		client_handle,
3513		(globus_soap_client_response_callback_func_t) callback,
3514		callback_arg);
3515		}
3516
3517		/**
3518		* Nonblocking operation invocation with EPR
3519		* @ingroup CounterPortType_add_operation
3520		*
3521		* Begin processing a request for the add operation. The operation will
3522		* sent to the service named by the @a epr and after the response is received,
3523		* the @a callback function will be invoked.
3524		*
3525		* @param handle
3526		* The @link #CounterService_client_handle_t client handle @endlink which
3527		* contains the state related to processing this operation.
3528		* @param epr
3529		* Endpoint Reference of the service and resource which will process
3530		* the operation.
3531		* @param input
3532		* Input parameter to the operation.
3533		* @param callback
3534		* Callback function which will be called once the operation has been
3535		* processed.
3536		* @param callback_arg
3537		* Application-specific pointer which will be passed to the callback.
3538		*/
3539		globus_result_t
3540		CounterPortType_add_epr_register(
3541		CounterService_client_handle_t handle,
3542		const wsa_EndpointReferenceType * epr,
3543		const xsd_int * input,
3544		CounterPortType_add_response_callback_func_t callback,
3545		void * callback_arg)
3546	0	{
3547		globus_result_t result;
3548
3549	0	result = globus_soap_client_handle_attr_set(
3550		handle,
3551		WSADDR_EPR_KEY,
3552		wsa_EndpointReferenceType_info.copy,
3553		wsa_EndpointReferenceType_info.destroy,
3554		(void *) epr);
3555
3556	0	if (result != GLOBUS_SUCCESS)
3557		{
3558	0	goto out;
3559		}
3560
3561	0	result = globus_soap_client_operation_register(
3562		handle,
3563		epr->Address.base_value,
3564		&CounterPortType_l_add_operation,
3565		(void *) input,
3566		(globus_soap_client_response_callback_func_t) callback,
3567		callback_arg);
3568	0	out:
3569	0	return result;
3570		}
3571
3572		/**
3573		* Nonblocking operation invocation
3574		* @ingroup CounterPortType_add_operation
3575		*
3576		* Begin processing a request for the add operation. The operation will
3577		* sent to the service located at @a endpoint and after the response is
3578		* received, the @a callback function will be invoked.
3579		*
3580		* @param handle
3581		* The @link #CounterService_client_handle_t client handle @endlink which
3582		* contains the state related to processing this operation.
3583		* @param endpoint
3584		* URI of the service endpoint to send the request to.
3585		* @param input
3586		* Input parameter to the operation.
3587		* @param callback
3588		* Callback function which will be called once the operation has been
3589		* processed.
3590		* @param callback_arg
3591		* Application-specific pointer which will be passed to the callback.
3592		*/
3593		globus_result_t
3594		CounterPortType_add_register(
3595		CounterService_client_handle_t handle,
3596		const char * endpoint,
3597		const xsd_int * input,
3598		CounterPortType_add_response_callback_func_t callback,
3599		void * callback_arg)
3600	0	{
3601	0	return globus_soap_client_operation_register(
3602		handle,
3603		endpoint,
3604		&CounterPortType_l_add_operation,
3605		(void *) input,
3606		(globus_soap_client_response_callback_func_t) callback,
3607		callback_arg);
3608		}
3609
3610
3611
3612		/**
3613		* Blocking operation invocation with EPR
3614		* @ingroup CounterPortType_add_operation
3615		*
3616		* Request that an the add operation be invoked by the service and
3617		* resource named by the @a epr parameter.
3618
3619		* If the result is <code>GLOBUS_SUCCESS</code>, then the
3620		* @a output parameter will be set to the result of the operation.
3621		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
3622		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
3623		* error occurred, and the result's error type should be checked.
3624
3625		*
3626		* @param handle
3627		* The @link #CounterService_client_handle_t client handle @endlink which
3628		* contains the state related to processing this operation.
3629		* @param epr
3630		* Endpoint Reference of the service and resource which will process
3631		* the operation.
3632		* @param input
3633		* Input parameter to the operation.
3634
3635		* @param output
3636		* The output of the operation, if the operation succeeded.
3637		* @param fault_type
3638		* The type of fault sent as a result of the operation, if the operation
3639		* failed. If the operation succeeded, this will be NULL.
3640		* @param fault
3641		* The fault element which was received, if the operation failed.
3642		* If the operation succeeded, this will be NULL.
3643
3644		*/
3645		globus_result_t
3646		CounterPortType_add_epr(
3647		CounterService_client_handle_t handle,
3648		const wsa_EndpointReferenceType * epr,
3649		const xsd_int * input,
3650		xsd_int * * output,
3651		CounterPortType_add_fault_t * fault_type,
3652		xsd_any * * fault)
3653	97	{
3654		globus_result_t result;
3655
3656	97	result = globus_soap_client_handle_attr_set(
3657		handle,
3658		WSADDR_EPR_KEY,
3659		wsa_EndpointReferenceType_info.copy,
3660		wsa_EndpointReferenceType_info.destroy,
3661		(void *) epr);
3662
3663	97	if (result != GLOBUS_SUCCESS)
3664		{
3665	0	goto out;
3666		}
3667	97	result = globus_soap_client_operation(
3668		handle,
3669		epr->Address.base_value,
3670		&CounterPortType_l_add_operation,
3671		(void *) input,
3672
3673		(void **) output,
3674		(int *) fault_type,
3675		fault
3676		);
3677	97	out:
3678	97	return result;
3679		}
3680
3681		/**
3682		* Blocking operation invocation
3683		* @ingroup CounterPortType_add_operation
3684		*
3685		* Request that an the add operation be invoked by the service at
3686		* @a endpoint.
3687
3688		* If the result is <code>GLOBUS_SUCCESS</code>, then the
3689		* @a output parameter will be set to the result of the operation.
3690		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
3691		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
3692		* error occurred, and the result's error type should be checked.
3693
3694		*
3695		* @param handle
3696		* The @link #CounterService_client_handle_t client handle @endlink which
3697		* contains the state related to processing this operation.
3698		* @param endpoint
3699		* URI of the service endpoint to send the request to.
3700		* @param input
3701		* Input parameter to the operation.
3702
3703		* @param output
3704		* The output of the operation, if the operation succeeded.
3705		* @param fault_type
3706		* The type of fault sent as a result of the operation, if the operation
3707		* failed. If the operation succeeded, this will be NULL.
3708		* @param fault
3709		* The fault element which was received, if the operation failed.
3710		* If the operation succeeded, this will be NULL.
3711
3712		*/
3713		globus_result_t
3714		CounterPortType_add(
3715		CounterService_client_handle_t handle,
3716		const char * endpoint,
3717		const xsd_int * input,
3718		xsd_int * * output,
3719		CounterPortType_add_fault_t * fault_type,
3720		xsd_any * * fault)
3721	0	{
3722	0	return globus_soap_client_operation(
3723		handle,
3724		endpoint,
3725		&CounterPortType_l_add_operation,
3726		(void *) input,
3727
3728		(void *) output,
3729		(int *) fault_type,
3730		fault
3731		);
3732		}
3733
3734
3735		/**
3736		* Nonblocking operation request with EPR
3737		* @ingroup CounterPortType_createCounter_operation
3738		* Begin sending a request for the <code>createCounter</code> operation on a
3739		* resource handled by the service named by the @a epr. When the operation
3740		* request has been sent, the @a callback function will be invoked.
3741		*
3742		* @param client_handle
3743		* The @link #CounterService_client_handle_t client handle @endlink which
3744		* contains the state related to processing this operation.
3745		* @param epr
3746		* Endpoint Reference of the service and resource which will process
3747		* the operation.
3748		* @param input
3749		* Input parameter to the operation.
3750		* @param callback
3751		* Callback function which will be called once the request has been
3752		* sent
3753		* @param callback_arg
3754		* Application-specific pointer which will be passed to the callback.
3755		*/
3756		globus_result_t
3757		CounterPortType_createCounter_epr_register_request(
3758		CounterService_client_handle_t client_handle,
3759		const wsa_EndpointReferenceType * epr,
3760		const counter_createCounterType * input,
3761		CounterPortType_createCounter_request_callback_func_t callback,
3762		void * callback_arg)
3763	0	{
3764	0	globus_result_t result = GLOBUS_SUCCESS;
3765
3766	0	globus_assert_string(epr, "NULL EndpointReference");
3767	0	globus_assert_string(epr->Address.base_value,
3768		"NULL EndpointReference Address");
3769
3770	0	result = globus_soap_client_handle_attr_set(
3771		client_handle,
3772		WSADDR_EPR_KEY,
3773		wsa_EndpointReferenceType_info.copy,
3774		wsa_EndpointReferenceType_info.destroy,
3775		(void *) epr);
3776
3777	0	if (result != GLOBUS_SUCCESS)
3778		{
3779	0	goto out;
3780		}
3781
3782	0	result = globus_soap_client_register_request(
3783		client_handle,
3784		epr->Address.base_value,
3785		&CounterPortType_l_createCounter_operation,
3786		(void *) input,
3787		callback,
3788		callback_arg);
3789
3790	0	out:
3791	0	return result;
3792		}
3793
3794		/**
3795		* Nonblocking operation request
3796		* @ingroup CounterPortType_createCounter_operation
3797		* Begin sending a request for the <code>createCounter</code> operation to
3798		* the service at @a endpoint. When the operation
3799		* request has been sent, the @a callback function will be invoked.
3800		* @param handle
3801		* The @link #CounterService_client_handle_t client handle @endlink which
3802		* contains the state related to processing this operation.
3803		* @param endpoint
3804		* URI of the service endpoint to send the request to.
3805		* @param input
3806		* Input parameter to the operation.
3807		* @param callback
3808		* Callback function which will be called once the request has been
3809		* sent
3810		* @param callback_arg
3811		* Application-specific pointer which will be passed to the callback.
3812		*/
3813		globus_result_t
3814		CounterPortType_createCounter_register_request(
3815		CounterService_client_handle_t client_handle,
3816		const char * endpoint,
3817		const counter_createCounterType * input,
3818		CounterPortType_createCounter_request_callback_func_t callback,
3819		void * callback_arg)
3820	0	{
3821	0	return globus_soap_client_register_request(
3822		client_handle,
3823		endpoint,
3824		&CounterPortType_l_createCounter_operation,
3825		(void *) input,
3826		callback,
3827		callback_arg);
3828		}
3829
3830
3831
3832		static
3833		void
3834		CounterPortType_l_createCounter_deserialize_fault(
3835		globus_soap_message_handle_t handle,
3836		const xsd_QName * fault_qname,
3837		int * fault_type)
3838	0	{
3839	0	*fault_type = COUNTERPORTTYPE_CREATECOUNTER_NOFAULT;
3840
3841	0	if(fault_qname)
3842		{
3843
3844		{
3845	0	*fault_type = COUNTERPORTTYPE_CREATECOUNTER_UNKNOWN_FAULT;
3846		}
3847		}
3848	0	}
3849		/* CounterPortType_l_createCounter_deserialize_fault() */
3850
3851		/**
3852		* Nonblocking operation response handling
3853		* @ingroup CounterPortType_createCounter_operation
3854		* Begin parsing the request for the <code>createCounter</code> operation begun
3855		* by an earlier call to
3856		* CounterPortType_createCounter_register_request() or
3857		* CounterPortType_createCounter_epr_register_request(). Once the response has been parsed.
3858		* the @a callback function will be called to pass the result of the operation
3859		* to the application.
3860		*
3861		* @param client_handle
3862		* The @link #CounterService_client_handle_t client handle @endlink which
3863		* contains the state related to processing this operation.
3864		* @param callback
3865		* Callback function which will be called once the response has been
3866		* processed.
3867		* @param callback_arg
3868		* Application-specific pointer which will be passed to the callback.
3869		*/
3870		globus_result_t
3871		CounterPortType_createCounter_register_response(
3872		CounterService_client_handle_t client_handle,
3873		CounterPortType_createCounter_response_callback_func_t callback,
3874		void * callback_arg)
3875	0	{
3876	0	return globus_soap_client_register_response(
3877		client_handle,
3878		(globus_soap_client_response_callback_func_t) callback,
3879		callback_arg);
3880		}
3881
3882		/**
3883		* Nonblocking operation invocation with EPR
3884		* @ingroup CounterPortType_createCounter_operation
3885		*
3886		* Begin processing a request for the createCounter operation. The operation will
3887		* sent to the service named by the @a epr and after the response is received,
3888		* the @a callback function will be invoked.
3889		*
3890		* @param handle
3891		* The @link #CounterService_client_handle_t client handle @endlink which
3892		* contains the state related to processing this operation.
3893		* @param epr
3894		* Endpoint Reference of the service and resource which will process
3895		* the operation.
3896		* @param input
3897		* Input parameter to the operation.
3898		* @param callback
3899		* Callback function which will be called once the operation has been
3900		* processed.
3901		* @param callback_arg
3902		* Application-specific pointer which will be passed to the callback.
3903		*/
3904		globus_result_t
3905		CounterPortType_createCounter_epr_register(
3906		CounterService_client_handle_t handle,
3907		const wsa_EndpointReferenceType * epr,
3908		const counter_createCounterType * input,
3909		CounterPortType_createCounter_response_callback_func_t callback,
3910		void * callback_arg)
3911	0	{
3912		globus_result_t result;
3913
3914	0	result = globus_soap_client_handle_attr_set(
3915		handle,
3916		WSADDR_EPR_KEY,
3917		wsa_EndpointReferenceType_info.copy,
3918		wsa_EndpointReferenceType_info.destroy,
3919		(void *) epr);
3920
3921	0	if (result != GLOBUS_SUCCESS)
3922		{
3923	0	goto out;
3924		}
3925
3926	0	result = globus_soap_client_operation_register(
3927		handle,
3928		epr->Address.base_value,
3929		&CounterPortType_l_createCounter_operation,
3930		(void *) input,
3931		(globus_soap_client_response_callback_func_t) callback,
3932		callback_arg);
3933	0	out:
3934	0	return result;
3935		}
3936
3937		/**
3938		* Nonblocking operation invocation
3939		* @ingroup CounterPortType_createCounter_operation
3940		*
3941		* Begin processing a request for the createCounter operation. The operation will
3942		* sent to the service located at @a endpoint and after the response is
3943		* received, the @a callback function will be invoked.
3944		*
3945		* @param handle
3946		* The @link #CounterService_client_handle_t client handle @endlink which
3947		* contains the state related to processing this operation.
3948		* @param endpoint
3949		* URI of the service endpoint to send the request to.
3950		* @param input
3951		* Input parameter to the operation.
3952		* @param callback
3953		* Callback function which will be called once the operation has been
3954		* processed.
3955		* @param callback_arg
3956		* Application-specific pointer which will be passed to the callback.
3957		*/
3958		globus_result_t
3959		CounterPortType_createCounter_register(
3960		CounterService_client_handle_t handle,
3961		const char * endpoint,
3962		const counter_createCounterType * input,
3963		CounterPortType_createCounter_response_callback_func_t callback,
3964		void * callback_arg)
3965	0	{
3966	0	return globus_soap_client_operation_register(
3967		handle,
3968		endpoint,
3969		&CounterPortType_l_createCounter_operation,
3970		(void *) input,
3971		(globus_soap_client_response_callback_func_t) callback,
3972		callback_arg);
3973		}
3974
3975
3976
3977		/**
3978		* Blocking operation invocation with EPR
3979		* @ingroup CounterPortType_createCounter_operation
3980		*
3981		* Request that an the createCounter operation be invoked by the service and
3982		* resource named by the @a epr parameter.
3983
3984		* If the result is <code>GLOBUS_SUCCESS</code>, then the
3985		* @a output parameter will be set to the result of the operation.
3986		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
3987		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
3988		* error occurred, and the result's error type should be checked.
3989
3990		*
3991		* @param handle
3992		* The @link #CounterService_client_handle_t client handle @endlink which
3993		* contains the state related to processing this operation.
3994		* @param epr
3995		* Endpoint Reference of the service and resource which will process
3996		* the operation.
3997		* @param input
3998		* Input parameter to the operation.
3999
4000		* @param output
4001		* The output of the operation, if the operation succeeded.
4002		* @param fault_type
4003		* The type of fault sent as a result of the operation, if the operation
4004		* failed. If the operation succeeded, this will be NULL.
4005		* @param fault
4006		* The fault element which was received, if the operation failed.
4007		* If the operation succeeded, this will be NULL.
4008
4009		*/
4010		globus_result_t
4011		CounterPortType_createCounter_epr(
4012		CounterService_client_handle_t handle,
4013		const wsa_EndpointReferenceType * epr,
4014		const counter_createCounterType * input,
4015		counter_createCounterResponseType * * output,
4016		CounterPortType_createCounter_fault_t * fault_type,
4017		xsd_any * * fault)
4018	0	{
4019		globus_result_t result;
4020
4021	0	result = globus_soap_client_handle_attr_set(
4022		handle,
4023		WSADDR_EPR_KEY,
4024		wsa_EndpointReferenceType_info.copy,
4025		wsa_EndpointReferenceType_info.destroy,
4026		(void *) epr);
4027
4028	0	if (result != GLOBUS_SUCCESS)
4029		{
4030	0	goto out;
4031		}
4032	0	result = globus_soap_client_operation(
4033		handle,
4034		epr->Address.base_value,
4035		&CounterPortType_l_createCounter_operation,
4036		(void *) input,
4037
4038		(void **) output,
4039		(int *) fault_type,
4040		fault
4041		);
4042	0	out:
4043	0	return result;
4044		}
4045
4046		/**
4047		* Blocking operation invocation
4048		* @ingroup CounterPortType_createCounter_operation
4049		*
4050		* Request that an the createCounter operation be invoked by the service at
4051		* @a endpoint.
4052
4053		* If the result is <code>GLOBUS_SUCCESS</code>, then the
4054		* @a output parameter will be set to the result of the operation.
4055		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
4056		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
4057		* error occurred, and the result's error type should be checked.
4058
4059		*
4060		* @param handle
4061		* The @link #CounterService_client_handle_t client handle @endlink which
4062		* contains the state related to processing this operation.
4063		* @param endpoint
4064		* URI of the service endpoint to send the request to.
4065		* @param input
4066		* Input parameter to the operation.
4067
4068		* @param output
4069		* The output of the operation, if the operation succeeded.
4070		* @param fault_type
4071		* The type of fault sent as a result of the operation, if the operation
4072		* failed. If the operation succeeded, this will be NULL.
4073		* @param fault
4074		* The fault element which was received, if the operation failed.
4075		* If the operation succeeded, this will be NULL.
4076
4077		*/
4078		globus_result_t
4079		CounterPortType_createCounter(
4080		CounterService_client_handle_t handle,
4081		const char * endpoint,
4082		const counter_createCounterType * input,
4083		counter_createCounterResponseType * * output,
4084		CounterPortType_createCounter_fault_t * fault_type,
4085		xsd_any * * fault)
4086	17	{
4087	17	return globus_soap_client_operation(
4088		handle,
4089		endpoint,
4090		&CounterPortType_l_createCounter_operation,
4091		(void *) input,
4092
4093		(void *) output,
4094		(int *) fault_type,
4095		fault
4096		);