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 "RegistryService_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 * RegistryService_l_extensions = NULL;
33		static globus_mutex_t RegistryService_l_extensions_mutex;
34
35		static
36		int
37		RegistryService_l_client_module_activate();
38
39		static
40		int
41		RegistryService_l_client_module_deactivate();
42
43		globus_module_descriptor_t
44		RegistryService_i_module =
45		{
46		"RegistryService",
47		RegistryService_l_client_module_activate,
48		RegistryService_l_client_module_deactivate
49		};
50
51
52		static
53		void
54		RegistryPortType_l_EnumerateOp_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 RegistryPortType_l_EnumerateOp_operation =
62		{
63		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "Enumerate" } ,
64		&wsen_EnumerateType_info,
65
66		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "EnumerateResponse" },
67		&wsen_EnumerateResponseType_info,
68
69		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/Enumerate",
70
71		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/EnumerateResponse",
72
73
74		RegistryPortType_l_EnumerateOp_deserialize_fault
75
76		};
77
78
79
80		static
81		globus_soap_client_operation_t RegistryPortType_l_ReleaseOp_operation =
82		{
83		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "Release" } ,
84		&wsen_ReleaseType_info,
85
86		{ NULL, NULL },
87		NULL,
88
89		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/Release",
90
91		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/ReleaseResponse",
92
93
94		NULL
95
96		};
97
98
99		static
100		void
101		RegistryPortType_l_GetStatusOp_deserialize_fault(
102		globus_soap_message_handle_t handle,
103		const xsd_QName * fault_qname,
104		int * fault_type);
105
106
107		static
108		globus_soap_client_operation_t RegistryPortType_l_GetStatusOp_operation =
109		{
110		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "GetStatus" } ,
111		&wsen_GetStatusType_info,
112
113		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "GetStatusResponse" },
114		&wsen_GetStatusResponseType_info,
115
116		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/GetStatus",
117
118		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/GetStatusResponse",
119
120
121		RegistryPortType_l_GetStatusOp_deserialize_fault
122
123		};
124
125
126		static
127		void
128		RegistryPortType_l_RenewOp_deserialize_fault(
129		globus_soap_message_handle_t handle,
130		const xsd_QName * fault_qname,
131		int * fault_type);
132
133
134		static
135		globus_soap_client_operation_t RegistryPortType_l_RenewOp_operation =
136		{
137		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "Renew" } ,
138		&wsen_RenewType_info,
139
140		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "RenewResponse" },
141		&wsen_RenewResponseType_info,
142
143		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/Renew",
144
145		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/RenewResponse",
146
147
148		RegistryPortType_l_RenewOp_deserialize_fault
149
150		};
151
152
153		static
154		void
155		RegistryPortType_l_PullOp_deserialize_fault(
156		globus_soap_message_handle_t handle,
157		const xsd_QName * fault_qname,
158		int * fault_type);
159
160
161		static
162		globus_soap_client_operation_t RegistryPortType_l_PullOp_operation =
163		{
164		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "Pull" } ,
165		&wsen_PullType_info,
166
167		{ "http://schemas.xmlsoap.org/ws/2004/09/enumeration", "PullResponse" },
168		&wsen_PullResponseType_info,
169
170		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/Pull",
171
172		"http://schemas.xmlsoap.org/ws/2004/09/enumeration/PullResponse",
173
174
175		RegistryPortType_l_PullOp_deserialize_fault
176
177		};
178
179
180		static
181		void
182		RegistryPortType_l_GetMultipleResourceProperties_deserialize_fault(
183		globus_soap_message_handle_t handle,
184		const xsd_QName * fault_qname,
185		int * fault_type);
186
187
188		static
189		globus_soap_client_operation_t RegistryPortType_l_GetMultipleResourceProperties_operation =
190		{
191		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetMultipleResourceProperties" } ,
192		&wsrp_GetMultipleResourcePropertiesType_info,
193
194		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetMultipleResourcePropertiesResponse" },
195		&wsrp_GetMultipleResourcePropertiesResponseType_info,
196
197		"http://docs.oasis-open.org/wsrf/rpw-2/GetMultipleResourceProperties/GetMultipleResourcePropertiesRequest",
198
199		"http://docs.oasis-open.org/wsrf/rpw-2/GetMultipleResourceProperties/GetMultipleResourcePropertiesResponse",
200
201
202		RegistryPortType_l_GetMultipleResourceProperties_deserialize_fault
203
204		};
205
206
207		static
208		void
209		RegistryPortType_l_QueryResourceProperties_deserialize_fault(
210		globus_soap_message_handle_t handle,
211		const xsd_QName * fault_qname,
212		int * fault_type);
213
214
215		static
216		globus_soap_client_operation_t RegistryPortType_l_QueryResourceProperties_operation =
217		{
218		{ "http://docs.oasis-open.org/wsrf/rp-2", "QueryResourceProperties" } ,
219		&wsrp_QueryResourcePropertiesType_info,
220
221		{ "http://docs.oasis-open.org/wsrf/rp-2", "QueryResourcePropertiesResponse" },
222		&wsrp_QueryResourcePropertiesResponseType_info,
223
224		"http://docs.oasis-open.org/wsrf/rpw-2/QueryResourceProperties/QueryResourcePropertiesRequest",
225
226		"http://docs.oasis-open.org/wsrf/rpw-2/QueryResourceProperties/QueryResourcePropertiesResponse",
227
228
229		RegistryPortType_l_QueryResourceProperties_deserialize_fault
230
231		};
232
233
234		static
235		void
236		RegistryPortType_l_GetResourceProperty_deserialize_fault(
237		globus_soap_message_handle_t handle,
238		const xsd_QName * fault_qname,
239		int * fault_type);
240
241
242		static
243		globus_soap_client_operation_t RegistryPortType_l_GetResourceProperty_operation =
244		{
245		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetResourceProperty" } ,
246		&xsd_QName_info,
247
248		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetResourcePropertyResponse" },
249		&wsrp_GetResourcePropertyResponseType_info,
250
251		"http://docs.oasis-open.org/wsrf/rpw-2/GetResourceProperty/GetResourcePropertyRequest",
252
253		"http://docs.oasis-open.org/wsrf/rpw-2/GetResourceProperty/GetResourcePropertyResponse",
254
255
256		RegistryPortType_l_GetResourceProperty_deserialize_fault
257
258		};
259
260
261		static
262		int
263		RegistryService_l_client_module_activate()
264	0	{
265	0	int res = 0;
266	0	globus_result_t result = GLOBUS_SUCCESS;
267	0	res = globus_module_activate(GLOBUS_SOAP_MESSAGE_MODULE);
268	0	if(res != GLOBUS_SUCCESS)
269		{
270	0	return res;
271		}
272
273	0	result = RegistryService_registry_add_types(GLOBUS_GLOBAL_TYPE_REGISTRY);
274	0	if(result != GLOBUS_SUCCESS)
275		{
276	0	result = GlobusSoapMessageErrorFailedClientInit(
277		result, "RegistryService");
278		}
279
280
281	0	globus_mutex_init(&RegistryService_l_extensions_mutex, NULL);
282
283	0	return res;
284		}
285
286		static
287		void
288		RegistryService_l_extension_destroy(
289		void * sym)
290	0	{
291	0	char * symbol = (char *) sym;
292
293	0	globus_extension_deactivate(symbol);
294	0	globus_free(symbol);
295	0	}
296
297		static
298		int
299		RegistryService_l_client_module_deactivate()
300	0	{
301	0	int res = 0;
302
303	0	globus_module_deactivate(GLOBUS_SOAP_MESSAGE_MODULE);
304
305	0	globus_mutex_lock(&RegistryService_l_extensions_mutex);
306	0	globus_list_destroy_all(
307		RegistryService_l_extensions,
308		RegistryService_l_extension_destroy);
309	0	RegistryService_l_extensions = NULL;
310	0	globus_mutex_unlock(&RegistryService_l_extensions_mutex);
311	0	globus_mutex_destroy(&RegistryService_l_extensions_mutex);
312
313	0	return res;
314		}
315
316		/**
317		* Initialize a client handle
318		* @ingroup RegistryService_client_handle
319		* Initialize new client handle state for use with operation-related functions.
320		*
321		* @param handle
322		* Pointer to the handle to initialize.
323		* @param attrs
324		* Default attributes to use with this handle. This parameter may be NULL.
325		* Certain atttributes may cause different handlers to be pushed onto the
326		* default handler chain for this client.
327		* @param handlers
328		* Handle chain to use with this handle. This parameter may be NULL.
329		* Typically the default handler chain used by this function is sufficient.
330		*/
331		globus_result_t
332		RegistryService_client_init(
333		RegistryService_client_handle_t * handle,
334		globus_soap_message_attr_t attrs,
335		globus_handler_chain_t chain)
336	0	{
337	0	RegistryService_client_handle_t client_handle = NULL;
338	0	globus_result_t result = GLOBUS_SUCCESS;
339	0	globus_handler_chain_t tmp_chain = NULL;
340		GlobusFuncName(RegistryService_client_init);
341	0	GlobusSoapMessageDebugEnter();
342
343	0	if (chain == NULL)
344		{
345	0	globus_handler_chain_init(&tmp_chain);
346
347	0	if(attrs &&
348		((int)globus_soap_message_attr_get(
349		attrs,
350		GLOBUS_SOAP_MESSAGE_AUTHENTICATION_METHOD_KEY)) ==
351		GLOBUS_SOAP_MESSAGE_AUTH_SECURE_MESSAGE)
352		{
353	0	result = globus_extension_activate(
354		"globus_handler_ws_secure_message");
355	0	if(result != GLOBUS_SUCCESS)
356		{
357	0	result = GlobusSoapMessageErrorFailedClientInit(
358		result, "RegistryPortType_GetResourceProperty");
359	0	goto error;
360		}
361
362	0	globus_mutex_lock(&RegistryService_l_extensions_mutex);
363	0	globus_list_insert(
364		&RegistryService_l_extensions,
365		strdup("globus_handler_ws_secure_message"));
366	0	globus_mutex_unlock(&RegistryService_l_extensions_mutex);
367
368	0	result = globus_handler_chain_push(
369		tmp_chain,
370		GLOBUS_HANDLER_TYPE_ALL,
371		"globus_handler_ws_secure_message_client");
372	0	if(result != GLOBUS_SUCCESS)
373		{
374	0	result = GlobusSoapMessageErrorFailedClientInit(
375		result, "RegistryPortType_GetResourceProperty");
376	0	goto error;
377		}
378		}
379
380	0	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
381	0	if(result != GLOBUS_SUCCESS)
382		{
383	0	result = GlobusSoapMessageErrorFailedClientInit(
384		result, "RegistryPortType_GetResourceProperty");
385	0	goto error;
386		}
387
388	0	globus_mutex_lock(&RegistryService_l_extensions_mutex);
389	0	globus_list_insert(
390		&RegistryService_l_extensions,
391		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
392	0	globus_mutex_unlock(&RegistryService_l_extensions_mutex);
393
394	0	result = globus_handler_chain_push(
395		tmp_chain,
396		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
397		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
398	0	if(result != GLOBUS_SUCCESS)
399		{
400	0	result = GlobusSoapMessageErrorFailedClientInit(
401		result, "RegistryPortType_GetResourceProperty");
402	0	goto error;
403		}
404
405	0	result = globus_handler_chain_push(
406		tmp_chain,
407		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
408		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
409	0	if(result != GLOBUS_SUCCESS)
410		{
411	0	result = GlobusSoapMessageErrorFailedClientInit(
412		result, "RegistryPortType_GetResourceProperty");
413	0	goto error;
414		}
415
416	0	chain = tmp_chain;
417		}
418
419	0	result = globus_soap_client_handle_init(
420		handle,
421		attrs,
422		chain);
423
424	0	GlobusSoapMessageDebugExit();
425	0	return result;
426
427	0	error:
428	0	if (tmp_chain != NULL)
429		{
430	0	globus_handler_chain_destroy(tmp_chain);
431		}
432	0	if (client_handle != NULL)
433		{
434	0	globus_free(client_handle);
435		}
436	0	GlobusSoapMessageDebugExit();
437	0	return result;
438		}
439		/* RegistryService_client_init() */
440
441		/**
442		* Destroy a client handle
443		* @ingroup RegistryService_client_handle
444		*
445		* Destroys the state associated with this client handle.
446		*
447		* @param handle
448		* Handle to destroy.
449		*/
450		void
451		RegistryService_client_destroy(
452		RegistryService_client_handle_t handle)
453	0	{
454	0	globus_soap_client_handle_destroy(handle);
455	0	}
456
457		/**
458		* Cancel the current operation associated with this handle.
459		* @ingroup RegistryService_client_handle
460		*
461		* @param handle
462		* Handle which has the operation to cancel.
463		*/
464		globus_result_t
465		RegistryService_client_operation_cancel(
466		RegistryService_client_handle_t handle)
467	0	{
468	0	globus_result_t result = GLOBUS_SUCCESS;
469		GlobusFuncName(RegistryService_client_message_cancel);
470	0	GlobusSoapMessageDebugEnter();
471
472	0	result = globus_soap_client_operation_cancel(handle);
473
474	0	return result;
475		}
476
477		/**
478		* Get handle's handler chain
479		* @ingroup RegistryService_client_handle
480		*
481		* The handler chain contains information about which handlers (typically
482		* SOAP header processors) will be invoked when a request is sent or a
483		* response is received. Applications which want to add custom handlers at
484		* run time may wish to push additional handlers onto this chain.
485		*
486		* @param handle
487		* The handle to query.
488		* @param handlers
489		* A pointer to a handler chain which will be set to the handle's
490		* chain.
491		*/
492		globus_result_t
493		RegistryService_client_get_handler_chain(
494		RegistryService_client_handle_t handle,
495		globus_handler_chain_t * handlers)
496	0	{
497	0	globus_result_t result = GLOBUS_SUCCESS;
498		GlobusFuncName(RegistryService_client_get_handle_chain);
499	0	GlobusSoapMessageDebugEnter();
500
501	0	result = globus_soap_client_handle_get_handler_chain(handle, handlers);
502
503	0	GlobusSoapMessageDebugExit();
504	0	return result;
505		}
506
507		/**
508		* Set a SOAP attribute on a handle
509		* @ingroup RegistryService_client_handle
510		*
511		* Set a SOAP attribute on a handle. This can be used to change how
512		* the SOAP engine will process operations sent via this handle.
513		*
514		* @param handle
515		* The handle to modify.
516		* @param prop_name
517		* The attribute name. This should be one of the
518		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
519		* @param copy
520		* A function to copy the value. This is required if @a value will go
521		* out of scope.
522		* @param destroy
523		* A function to destroy a copy of the value. Required if @a copy is set.
524		* @param value
525		* The new value of the attribute.
526		*/
527		globus_result_t
528		RegistryService_client_attr_set(
529		RegistryService_client_handle_t handle,
530		const char * prop_name,
531		globus_soap_message_attr_copy_func_t copy,
532		globus_soap_message_attr_destroy_func_t destroy,
533		void * value)
534	0	{
535	0	return globus_soap_client_handle_attr_set(
536		handle,
537		prop_name,
538		copy,
539		destroy,
540		value);
541		}
542
543		/**
544		* Remove a SOAP attribute from a handle
545		* @ingroup RegistryService_client_handle
546		*
547		* Remove a SOAP attribute on a handle. This can be used to change how
548		* the SOAP engine will process operations sent via this handle.
549		*
550		* @param handle
551		* The handle to modify.
552		* @param prop_name
553		* The attribute name. This should be one of the
554		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
555		*
556		* @return
557		* This function returns the current value of the attribute.
558		*/
559		void *
560		RegistryService_client_attr_remove(
561		RegistryService_client_handle_t handle,
562		const char * prop_name)
563	0	{
564	0	return globus_soap_client_handle_attr_remove(
565		handle,
566		prop_name);
567		}
568
569		/**
570		* Get a SOAP attribute from a handle
571		* @ingroup RegistryService_client_handle
572		*
573		* Get the current value of a SOAP attribute set on a handle.
574		*
575		* @param handle
576		* The handle to query.
577		* @param prop_name
578		* The attribute name. This should be one of the
579		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
580		*
581		* @return
582		* This function returns the current value of the attribute.
583		*/
584		void *
585		RegistryService_client_attr_get(
586		RegistryService_client_handle_t handle,
587		const char * prop_name)
588	0	{
589	0	return globus_soap_client_handle_attr_get(
590		handle,
591		prop_name);
592		}
593
594
595
596		/**
597		* Nonblocking operation request with EPR
598		* @ingroup RegistryPortType_EnumerateOp_operation
599		* Begin sending a request for the <code>EnumerateOp</code> operation on a
600		* resource handled by the service named by the @a epr. When the operation
601		* request has been sent, the @a callback function will be invoked.
602		*
603		* @param client_handle
604		* The @link #RegistryService_client_handle_t client handle @endlink which
605		* contains the state related to processing this operation.
606		* @param epr
607		* Endpoint Reference of the service and resource which will process
608		* the operation.
609		* @param input
610		* Input parameter to the operation.
611		* @param callback
612		* Callback function which will be called once the request has been
613		* sent
614		* @param callback_arg
615		* Application-specific pointer which will be passed to the callback.
616		*/
617		globus_result_t
618		RegistryPortType_EnumerateOp_epr_register_request(
619		RegistryService_client_handle_t client_handle,
620		const wsa_EndpointReferenceType * epr,
621		const wsen_EnumerateType * input,
622		RegistryPortType_EnumerateOp_request_callback_func_t callback,
623		void * callback_arg)
624	0	{
625	0	globus_result_t result = GLOBUS_SUCCESS;
626
627	0	globus_assert_string(epr, "NULL EndpointReference");
628	0	globus_assert_string(epr->Address.base_value,
629		"NULL EndpointReference Address");
630
631	0	result = globus_soap_client_handle_attr_set(
632		client_handle,
633		WSADDR_EPR_KEY,
634		wsa_EndpointReferenceType_info.copy,
635		wsa_EndpointReferenceType_info.destroy,
636		(void *) epr);
637
638	0	if (result != GLOBUS_SUCCESS)
639		{
640	0	goto out;
641		}
642
643	0	result = globus_soap_client_register_request(
644		client_handle,
645		epr->Address.base_value,
646		&RegistryPortType_l_EnumerateOp_operation,
647		(void *) input,
648		callback,
649		callback_arg);
650
651	0	out:
652	0	return result;
653		}
654
655		/**
656		* Nonblocking operation request
657		* @ingroup RegistryPortType_EnumerateOp_operation
658		* Begin sending a request for the <code>EnumerateOp</code> operation to
659		* the service at @a endpoint. When the operation
660		* request has been sent, the @a callback function will be invoked.
661		* @param handle
662		* The @link #RegistryService_client_handle_t client handle @endlink which
663		* contains the state related to processing this operation.
664		* @param endpoint
665		* URI of the service endpoint to send the request to.
666		* @param input
667		* Input parameter to the operation.
668		* @param callback
669		* Callback function which will be called once the request has been
670		* sent
671		* @param callback_arg
672		* Application-specific pointer which will be passed to the callback.
673		*/
674		globus_result_t
675		RegistryPortType_EnumerateOp_register_request(
676		RegistryService_client_handle_t client_handle,
677		const char * endpoint,
678		const wsen_EnumerateType * input,
679		RegistryPortType_EnumerateOp_request_callback_func_t callback,
680		void * callback_arg)
681	0	{
682	0	return globus_soap_client_register_request(
683		client_handle,
684		endpoint,
685		&RegistryPortType_l_EnumerateOp_operation,
686		(void *) input,
687		callback,
688		callback_arg);
689		}
690
691
692
693		static
694		void
695		RegistryPortType_l_EnumerateOp_deserialize_fault(
696		globus_soap_message_handle_t handle,
697		const xsd_QName * fault_qname,
698		int * fault_type)
699	0	{
700	0	*fault_type = REGISTRYPORTTYPE_ENUMERATEOP_NOFAULT;
701
702	0	if(fault_qname)
703		{
704
705		{
706	0	*fault_type = REGISTRYPORTTYPE_ENUMERATEOP_UNKNOWN_FAULT;
707		}
708		}
709	0	}
710		/* RegistryPortType_l_EnumerateOp_deserialize_fault() */
711
712		/**
713		* Nonblocking operation response handling
714		* @ingroup RegistryPortType_EnumerateOp_operation
715		* Begin parsing the request for the <code>EnumerateOp</code> operation begun
716		* by an earlier call to
717		* RegistryPortType_EnumerateOp_register_request() or
718		* RegistryPortType_EnumerateOp_epr_register_request(). Once the response has been parsed.
719		* the @a callback function will be called to pass the result of the operation
720		* to the application.
721		*
722		* @param client_handle
723		* The @link #RegistryService_client_handle_t client handle @endlink which
724		* contains the state related to processing this operation.
725		* @param callback
726		* Callback function which will be called once the response has been
727		* processed.
728		* @param callback_arg
729		* Application-specific pointer which will be passed to the callback.
730		*/
731		globus_result_t
732		RegistryPortType_EnumerateOp_register_response(
733		RegistryService_client_handle_t client_handle,
734		RegistryPortType_EnumerateOp_response_callback_func_t callback,
735		void * callback_arg)
736	0	{
737	0	return globus_soap_client_register_response(
738		client_handle,
739		(globus_soap_client_response_callback_func_t) callback,
740		callback_arg);
741		}
742
743		/**
744		* Nonblocking operation invocation with EPR
745		* @ingroup RegistryPortType_EnumerateOp_operation
746		*
747		* Begin processing a request for the EnumerateOp operation. The operation will
748		* sent to the service named by the @a epr and after the response is received,
749		* the @a callback function will be invoked.
750		*
751		* @param handle
752		* The @link #RegistryService_client_handle_t client handle @endlink which
753		* contains the state related to processing this operation.
754		* @param epr
755		* Endpoint Reference of the service and resource which will process
756		* the operation.
757		* @param input
758		* Input parameter to the operation.
759		* @param callback
760		* Callback function which will be called once the operation has been
761		* processed.
762		* @param callback_arg
763		* Application-specific pointer which will be passed to the callback.
764		*/
765		globus_result_t
766		RegistryPortType_EnumerateOp_epr_register(
767		RegistryService_client_handle_t handle,
768		const wsa_EndpointReferenceType * epr,
769		const wsen_EnumerateType * input,
770		RegistryPortType_EnumerateOp_response_callback_func_t callback,
771		void * callback_arg)
772	0	{
773		globus_result_t result;
774
775	0	result = globus_soap_client_handle_attr_set(
776		handle,
777		WSADDR_EPR_KEY,
778		wsa_EndpointReferenceType_info.copy,
779		wsa_EndpointReferenceType_info.destroy,
780		(void *) epr);
781
782	0	if (result != GLOBUS_SUCCESS)
783		{
784	0	goto out;
785		}
786
787	0	result = globus_soap_client_operation_register(
788		handle,
789		epr->Address.base_value,
790		&RegistryPortType_l_EnumerateOp_operation,
791		(void *) input,
792		(globus_soap_client_response_callback_func_t) callback,
793		callback_arg);
794	0	out:
795	0	return result;
796		}
797
798		/**
799		* Nonblocking operation invocation
800		* @ingroup RegistryPortType_EnumerateOp_operation
801		*
802		* Begin processing a request for the EnumerateOp operation. The operation will
803		* sent to the service located at @a endpoint and after the response is
804		* received, the @a callback function will be invoked.
805		*
806		* @param handle
807		* The @link #RegistryService_client_handle_t client handle @endlink which
808		* contains the state related to processing this operation.
809		* @param endpoint
810		* URI of the service endpoint to send the request to.
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		RegistryPortType_EnumerateOp_register(
821		RegistryService_client_handle_t handle,
822		const char * endpoint,
823		const wsen_EnumerateType * input,
824		RegistryPortType_EnumerateOp_response_callback_func_t callback,
825		void * callback_arg)
826	0	{
827	0	return globus_soap_client_operation_register(
828		handle,
829		endpoint,
830		&RegistryPortType_l_EnumerateOp_operation,
831		(void *) input,
832		(globus_soap_client_response_callback_func_t) callback,
833		callback_arg);
834		}
835
836
837
838		/**
839		* Blocking operation invocation with EPR
840		* @ingroup RegistryPortType_EnumerateOp_operation
841		*
842		* Request that an the EnumerateOp operation be invoked by the service and
843		* resource named by the @a epr parameter.
844
845		* If the result is <code>GLOBUS_SUCCESS</code>, then the
846		* @a output parameter will be set to the result of the operation.
847		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
848		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
849		* error occurred, and the result's error type should be checked.
850
851		*
852		* @param handle
853		* The @link #RegistryService_client_handle_t client handle @endlink which
854		* contains the state related to processing this operation.
855		* @param epr
856		* Endpoint Reference of the service and resource which will process
857		* the operation.
858		* @param input
859		* Input parameter to the operation.
860
861		* @param output
862		* The output of the operation, if the operation succeeded.
863		* @param fault_type
864		* The type of fault sent as a result of the operation, if the operation
865		* failed. If the operation succeeded, this will be NULL.
866		* @param fault
867		* The fault element which was received, if the operation failed.
868		* If the operation succeeded, this will be NULL.
869
870		*/
871		globus_result_t
872		RegistryPortType_EnumerateOp_epr(
873		RegistryService_client_handle_t handle,
874		const wsa_EndpointReferenceType * epr,
875		const wsen_EnumerateType * input,
876		wsen_EnumerateResponseType * * output,
877		RegistryPortType_EnumerateOp_fault_t * fault_type,
878		xsd_any * * fault)
879	0	{
880		globus_result_t result;
881
882	0	result = globus_soap_client_handle_attr_set(
883		handle,
884		WSADDR_EPR_KEY,
885		wsa_EndpointReferenceType_info.copy,
886		wsa_EndpointReferenceType_info.destroy,
887		(void *) epr);
888
889	0	if (result != GLOBUS_SUCCESS)
890		{
891	0	goto out;
892		}
893	0	result = globus_soap_client_operation(
894		handle,
895		epr->Address.base_value,
896		&RegistryPortType_l_EnumerateOp_operation,
897		(void *) input,
898
899		(void **) output,
900		(int *) fault_type,
901		fault
902		);
903	0	out:
904	0	return result;
905		}
906
907		/**
908		* Blocking operation invocation
909		* @ingroup RegistryPortType_EnumerateOp_operation
910		*
911		* Request that an the EnumerateOp operation be invoked by the service at
912		* @a endpoint.
913
914		* If the result is <code>GLOBUS_SUCCESS</code>, then the
915		* @a output parameter will be set to the result of the operation.
916		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
917		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
918		* error occurred, and the result's error type should be checked.
919
920		*
921		* @param handle
922		* The @link #RegistryService_client_handle_t client handle @endlink which
923		* contains the state related to processing this operation.
924		* @param endpoint
925		* URI of the service endpoint to send the request to.
926		* @param input
927		* Input parameter to the operation.
928
929		* @param output
930		* The output of the operation, if the operation succeeded.
931		* @param fault_type
932		* The type of fault sent as a result of the operation, if the operation
933		* failed. If the operation succeeded, this will be NULL.
934		* @param fault
935		* The fault element which was received, if the operation failed.
936		* If the operation succeeded, this will be NULL.
937
938		*/
939		globus_result_t
940		RegistryPortType_EnumerateOp(
941		RegistryService_client_handle_t handle,
942		const char * endpoint,
943		const wsen_EnumerateType * input,
944		wsen_EnumerateResponseType * * output,
945		RegistryPortType_EnumerateOp_fault_t * fault_type,
946		xsd_any * * fault)
947	0	{
948	0	return globus_soap_client_operation(
949		handle,
950		endpoint,
951		&RegistryPortType_l_EnumerateOp_operation,
952		(void *) input,
953
954		(void *) output,
955		(int *) fault_type,
956		fault
957		);
958		}
959
960
961		/**
962		* Nonblocking operation request with EPR
963		* @ingroup RegistryPortType_ReleaseOp_operation
964		* Begin sending a request for the <code>ReleaseOp</code> operation on a
965		* resource handled by the service named by the @a epr. When the operation
966		* request has been sent, the @a callback function will be invoked.
967		*
968		* @param client_handle
969		* The @link #RegistryService_client_handle_t client handle @endlink which
970		* contains the state related to processing this operation.
971		* @param epr
972		* Endpoint Reference of the service and resource which will process
973		* the operation.
974		* @param input
975		* Input parameter to the operation.
976		* @param callback
977		* Callback function which will be called once the request has been
978		* sent
979		* @param callback_arg
980		* Application-specific pointer which will be passed to the callback.
981		*/
982		globus_result_t
983		RegistryPortType_ReleaseOp_epr_register_request(
984		RegistryService_client_handle_t client_handle,
985		const wsa_EndpointReferenceType * epr,
986		const wsen_ReleaseType * input,
987		RegistryPortType_ReleaseOp_request_callback_func_t callback,
988		void * callback_arg)
989	0	{
990	0	globus_result_t result = GLOBUS_SUCCESS;
991
992	0	globus_assert_string(epr, "NULL EndpointReference");
993	0	globus_assert_string(epr->Address.base_value,
994		"NULL EndpointReference Address");
995
996	0	result = globus_soap_client_handle_attr_set(
997		client_handle,
998		WSADDR_EPR_KEY,
999		wsa_EndpointReferenceType_info.copy,
1000		wsa_EndpointReferenceType_info.destroy,
1001		(void *) epr);
1002
1003	0	if (result != GLOBUS_SUCCESS)
1004		{
1005	0	goto out;
1006		}
1007
1008	0	result = globus_soap_client_register_request(
1009		client_handle,
1010		epr->Address.base_value,
1011		&RegistryPortType_l_ReleaseOp_operation,
1012		(void *) input,
1013		callback,
1014		callback_arg);
1015
1016	0	out:
1017	0	return result;
1018		}
1019
1020		/**
1021		* Nonblocking operation request
1022		* @ingroup RegistryPortType_ReleaseOp_operation
1023		* Begin sending a request for the <code>ReleaseOp</code> operation to
1024		* the service at @a endpoint. When the operation
1025		* request has been sent, the @a callback function will be invoked.
1026		* @param handle
1027		* The @link #RegistryService_client_handle_t client handle @endlink which
1028		* contains the state related to processing this operation.
1029		* @param endpoint
1030		* URI of the service endpoint to send the request to.
1031		* @param input
1032		* Input parameter to the operation.
1033		* @param callback
1034		* Callback function which will be called once the request has been
1035		* sent
1036		* @param callback_arg
1037		* Application-specific pointer which will be passed to the callback.
1038		*/
1039		globus_result_t
1040		RegistryPortType_ReleaseOp_register_request(
1041		RegistryService_client_handle_t client_handle,
1042		const char * endpoint,
1043		const wsen_ReleaseType * input,
1044		RegistryPortType_ReleaseOp_request_callback_func_t callback,
1045		void * callback_arg)
1046	0	{
1047	0	return globus_soap_client_register_request(
1048		client_handle,
1049		endpoint,
1050		&RegistryPortType_l_ReleaseOp_operation,
1051		(void *) input,
1052		callback,
1053		callback_arg);
1054		}
1055
1056
1057
1058		/**
1059		* Blocking operation invocation with EPR
1060		* @ingroup RegistryPortType_ReleaseOp_operation
1061		*
1062		* Request that an the ReleaseOp operation be invoked by the service and
1063		* resource named by the @a epr parameter.
1064
1065		*
1066		* @param handle
1067		* The @link #RegistryService_client_handle_t client handle @endlink which
1068		* contains the state related to processing this operation.
1069		* @param epr
1070		* Endpoint Reference of the service and resource which will process
1071		* the operation.
1072		* @param input
1073		* Input parameter to the operation.
1074
1075		*/
1076		globus_result_t
1077		RegistryPortType_ReleaseOp_epr(
1078		RegistryService_client_handle_t handle,
1079		const wsa_EndpointReferenceType * epr,
1080		const wsen_ReleaseType * input)
1081	0	{
1082		globus_result_t result;
1083
1084	0	result = globus_soap_client_handle_attr_set(
1085		handle,
1086		WSADDR_EPR_KEY,
1087		wsa_EndpointReferenceType_info.copy,
1088		wsa_EndpointReferenceType_info.destroy,
1089		(void *) epr);
1090
1091	0	if (result != GLOBUS_SUCCESS)
1092		{
1093	0	goto out;
1094		}
1095	0	result = globus_soap_client_operation(
1096		handle,
1097		epr->Address.base_value,
1098		&RegistryPortType_l_ReleaseOp_operation,
1099		(void *) input,
1100
1101		NULL,
1102		NULL,
1103		NULL
1104		);
1105	0	out:
1106	0	return result;
1107		}
1108
1109		/**
1110		* Blocking operation invocation
1111		* @ingroup RegistryPortType_ReleaseOp_operation
1112		*
1113		* Request that an the ReleaseOp operation be invoked by the service at
1114		* @a endpoint.
1115
1116		*
1117		* @param handle
1118		* The @link #RegistryService_client_handle_t client handle @endlink which
1119		* contains the state related to processing this operation.
1120		* @param endpoint
1121		* URI of the service endpoint to send the request to.
1122		* @param input
1123		* Input parameter to the operation.
1124
1125		*/
1126		globus_result_t
1127		RegistryPortType_ReleaseOp(
1128		RegistryService_client_handle_t handle,
1129		const char * endpoint,
1130		const wsen_ReleaseType * input)
1131	0	{
1132	0	return globus_soap_client_operation(
1133		handle,
1134		endpoint,
1135		&RegistryPortType_l_ReleaseOp_operation,
1136		(void *) input,
1137
1138		NULL,
1139		NULL,
1140		NULL
1141		);
1142		}
1143
1144
1145		/**
1146		* Nonblocking operation request with EPR
1147		* @ingroup RegistryPortType_GetStatusOp_operation
1148		* Begin sending a request for the <code>GetStatusOp</code> operation on a
1149		* resource handled by the service named by the @a epr. When the operation
1150		* request has been sent, the @a callback function will be invoked.
1151		*
1152		* @param client_handle
1153		* The @link #RegistryService_client_handle_t client handle @endlink which
1154		* contains the state related to processing this operation.
1155		* @param epr
1156		* Endpoint Reference of the service and resource which will process
1157		* the operation.
1158		* @param input
1159		* Input parameter to the operation.
1160		* @param callback
1161		* Callback function which will be called once the request has been
1162		* sent
1163		* @param callback_arg
1164		* Application-specific pointer which will be passed to the callback.
1165		*/
1166		globus_result_t
1167		RegistryPortType_GetStatusOp_epr_register_request(
1168		RegistryService_client_handle_t client_handle,
1169		const wsa_EndpointReferenceType * epr,
1170		const wsen_GetStatusType * input,
1171		RegistryPortType_GetStatusOp_request_callback_func_t callback,
1172		void * callback_arg)
1173	0	{
1174	0	globus_result_t result = GLOBUS_SUCCESS;
1175
1176	0	globus_assert_string(epr, "NULL EndpointReference");
1177	0	globus_assert_string(epr->Address.base_value,
1178		"NULL EndpointReference Address");
1179
1180	0	result = globus_soap_client_handle_attr_set(
1181		client_handle,
1182		WSADDR_EPR_KEY,
1183		wsa_EndpointReferenceType_info.copy,
1184		wsa_EndpointReferenceType_info.destroy,
1185		(void *) epr);
1186
1187	0	if (result != GLOBUS_SUCCESS)
1188		{
1189	0	goto out;
1190		}
1191
1192	0	result = globus_soap_client_register_request(
1193		client_handle,
1194		epr->Address.base_value,
1195		&RegistryPortType_l_GetStatusOp_operation,
1196		(void *) input,
1197		callback,
1198		callback_arg);
1199
1200	0	out:
1201	0	return result;
1202		}
1203
1204		/**
1205		* Nonblocking operation request
1206		* @ingroup RegistryPortType_GetStatusOp_operation
1207		* Begin sending a request for the <code>GetStatusOp</code> operation to
1208		* the service at @a endpoint. When the operation
1209		* request has been sent, the @a callback function will be invoked.
1210		* @param handle
1211		* The @link #RegistryService_client_handle_t client handle @endlink which
1212		* contains the state related to processing this operation.
1213		* @param endpoint
1214		* URI of the service endpoint to send the request to.
1215		* @param input
1216		* Input parameter to the operation.
1217		* @param callback
1218		* Callback function which will be called once the request has been
1219		* sent
1220		* @param callback_arg
1221		* Application-specific pointer which will be passed to the callback.
1222		*/
1223		globus_result_t
1224		RegistryPortType_GetStatusOp_register_request(
1225		RegistryService_client_handle_t client_handle,
1226		const char * endpoint,
1227		const wsen_GetStatusType * input,
1228		RegistryPortType_GetStatusOp_request_callback_func_t callback,
1229		void * callback_arg)
1230	0	{
1231	0	return globus_soap_client_register_request(
1232		client_handle,
1233		endpoint,
1234		&RegistryPortType_l_GetStatusOp_operation,
1235		(void *) input,
1236		callback,
1237		callback_arg);
1238		}
1239
1240
1241
1242		static
1243		void
1244		RegistryPortType_l_GetStatusOp_deserialize_fault(
1245		globus_soap_message_handle_t handle,
1246		const xsd_QName * fault_qname,
1247		int * fault_type)
1248	0	{
1249	0	*fault_type = REGISTRYPORTTYPE_GETSTATUSOP_NOFAULT;
1250
1251	0	if(fault_qname)
1252		{
1253
1254		{
1255	0	*fault_type = REGISTRYPORTTYPE_GETSTATUSOP_UNKNOWN_FAULT;
1256		}
1257		}
1258	0	}
1259		/* RegistryPortType_l_GetStatusOp_deserialize_fault() */
1260
1261		/**
1262		* Nonblocking operation response handling
1263		* @ingroup RegistryPortType_GetStatusOp_operation
1264		* Begin parsing the request for the <code>GetStatusOp</code> operation begun
1265		* by an earlier call to
1266		* RegistryPortType_GetStatusOp_register_request() or
1267		* RegistryPortType_GetStatusOp_epr_register_request(). Once the response has been parsed.
1268		* the @a callback function will be called to pass the result of the operation
1269		* to the application.
1270		*
1271		* @param client_handle
1272		* The @link #RegistryService_client_handle_t client handle @endlink which
1273		* contains the state related to processing this operation.
1274		* @param callback
1275		* Callback function which will be called once the response has been
1276		* processed.
1277		* @param callback_arg
1278		* Application-specific pointer which will be passed to the callback.
1279		*/
1280		globus_result_t
1281		RegistryPortType_GetStatusOp_register_response(
1282		RegistryService_client_handle_t client_handle,
1283		RegistryPortType_GetStatusOp_response_callback_func_t callback,
1284		void * callback_arg)
1285	0	{
1286	0	return globus_soap_client_register_response(
1287		client_handle,
1288		(globus_soap_client_response_callback_func_t) callback,
1289		callback_arg);
1290		}
1291
1292		/**
1293		* Nonblocking operation invocation with EPR
1294		* @ingroup RegistryPortType_GetStatusOp_operation
1295		*
1296		* Begin processing a request for the GetStatusOp operation. The operation will
1297		* sent to the service named by the @a epr and after the response is received,
1298		* the @a callback function will be invoked.
1299		*
1300		* @param handle
1301		* The @link #RegistryService_client_handle_t client handle @endlink which
1302		* contains the state related to processing this operation.
1303		* @param epr
1304		* Endpoint Reference of the service and resource which will process
1305		* the operation.
1306		* @param input
1307		* Input parameter to the operation.
1308		* @param callback
1309		* Callback function which will be called once the operation has been
1310		* processed.
1311		* @param callback_arg
1312		* Application-specific pointer which will be passed to the callback.
1313		*/
1314		globus_result_t
1315		RegistryPortType_GetStatusOp_epr_register(
1316		RegistryService_client_handle_t handle,
1317		const wsa_EndpointReferenceType * epr,
1318		const wsen_GetStatusType * input,
1319		RegistryPortType_GetStatusOp_response_callback_func_t callback,
1320		void * callback_arg)
1321	0	{
1322		globus_result_t result;
1323
1324	0	result = globus_soap_client_handle_attr_set(
1325		handle,
1326		WSADDR_EPR_KEY,
1327		wsa_EndpointReferenceType_info.copy,
1328		wsa_EndpointReferenceType_info.destroy,
1329		(void *) epr);
1330
1331	0	if (result != GLOBUS_SUCCESS)
1332		{
1333	0	goto out;
1334		}
1335
1336	0	result = globus_soap_client_operation_register(
1337		handle,
1338		epr->Address.base_value,
1339		&RegistryPortType_l_GetStatusOp_operation,
1340		(void *) input,
1341		(globus_soap_client_response_callback_func_t) callback,
1342		callback_arg);
1343	0	out:
1344	0	return result;
1345		}
1346
1347		/**
1348		* Nonblocking operation invocation
1349		* @ingroup RegistryPortType_GetStatusOp_operation
1350		*
1351		* Begin processing a request for the GetStatusOp operation. The operation will
1352		* sent to the service located at @a endpoint and after the response is
1353		* received, the @a callback function will be invoked.
1354		*
1355		* @param handle
1356		* The @link #RegistryService_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		* @param callback
1363		* Callback function which will be called once the operation has been
1364		* processed.
1365		* @param callback_arg
1366		* Application-specific pointer which will be passed to the callback.
1367		*/
1368		globus_result_t
1369		RegistryPortType_GetStatusOp_register(
1370		RegistryService_client_handle_t handle,
1371		const char * endpoint,
1372		const wsen_GetStatusType * input,
1373		RegistryPortType_GetStatusOp_response_callback_func_t callback,
1374		void * callback_arg)
1375	0	{
1376	0	return globus_soap_client_operation_register(
1377		handle,
1378		endpoint,
1379		&RegistryPortType_l_GetStatusOp_operation,
1380		(void *) input,
1381		(globus_soap_client_response_callback_func_t) callback,
1382		callback_arg);
1383		}
1384
1385
1386
1387		/**
1388		* Blocking operation invocation with EPR
1389		* @ingroup RegistryPortType_GetStatusOp_operation
1390		*
1391		* Request that an the GetStatusOp operation be invoked by the service and
1392		* resource named by the @a epr parameter.
1393
1394		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1395		* @a output parameter will be set to the result of the operation.
1396		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1397		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1398		* error occurred, and the result's error type should be checked.
1399
1400		*
1401		* @param handle
1402		* The @link #RegistryService_client_handle_t client handle @endlink which
1403		* contains the state related to processing this operation.
1404		* @param epr
1405		* Endpoint Reference of the service and resource which will process
1406		* the operation.
1407		* @param input
1408		* Input parameter to the operation.
1409
1410		* @param output
1411		* The output of the operation, if the operation succeeded.
1412		* @param fault_type
1413		* The type of fault sent as a result of the operation, if the operation
1414		* failed. If the operation succeeded, this will be NULL.
1415		* @param fault
1416		* The fault element which was received, if the operation failed.
1417		* If the operation succeeded, this will be NULL.
1418
1419		*/
1420		globus_result_t
1421		RegistryPortType_GetStatusOp_epr(
1422		RegistryService_client_handle_t handle,
1423		const wsa_EndpointReferenceType * epr,
1424		const wsen_GetStatusType * input,
1425		wsen_GetStatusResponseType * * output,
1426		RegistryPortType_GetStatusOp_fault_t * fault_type,
1427		xsd_any * * fault)
1428	0	{
1429		globus_result_t result;
1430
1431	0	result = globus_soap_client_handle_attr_set(
1432		handle,
1433		WSADDR_EPR_KEY,
1434		wsa_EndpointReferenceType_info.copy,
1435		wsa_EndpointReferenceType_info.destroy,
1436		(void *) epr);
1437
1438	0	if (result != GLOBUS_SUCCESS)
1439		{
1440	0	goto out;
1441		}
1442	0	result = globus_soap_client_operation(
1443		handle,
1444		epr->Address.base_value,
1445		&RegistryPortType_l_GetStatusOp_operation,
1446		(void *) input,
1447
1448		(void **) output,
1449		(int *) fault_type,
1450		fault
1451		);
1452	0	out:
1453	0	return result;
1454		}
1455
1456		/**
1457		* Blocking operation invocation
1458		* @ingroup RegistryPortType_GetStatusOp_operation
1459		*
1460		* Request that an the GetStatusOp operation be invoked by the service at
1461		* @a endpoint.
1462
1463		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1464		* @a output parameter will be set to the result of the operation.
1465		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1466		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1467		* error occurred, and the result's error type should be checked.
1468
1469		*
1470		* @param handle
1471		* The @link #RegistryService_client_handle_t client handle @endlink which
1472		* contains the state related to processing this operation.
1473		* @param endpoint
1474		* URI of the service endpoint to send the request to.
1475		* @param input
1476		* Input parameter to the operation.
1477
1478		* @param output
1479		* The output of the operation, if the operation succeeded.
1480		* @param fault_type
1481		* The type of fault sent as a result of the operation, if the operation
1482		* failed. If the operation succeeded, this will be NULL.
1483		* @param fault
1484		* The fault element which was received, if the operation failed.
1485		* If the operation succeeded, this will be NULL.
1486
1487		*/
1488		globus_result_t
1489		RegistryPortType_GetStatusOp(
1490		RegistryService_client_handle_t handle,
1491		const char * endpoint,
1492		const wsen_GetStatusType * input,
1493		wsen_GetStatusResponseType * * output,
1494		RegistryPortType_GetStatusOp_fault_t * fault_type,
1495		xsd_any * * fault)
1496	0	{
1497	0	return globus_soap_client_operation(
1498		handle,
1499		endpoint,
1500		&RegistryPortType_l_GetStatusOp_operation,
1501		(void *) input,
1502
1503		(void *) output,
1504		(int *) fault_type,
1505		fault
1506		);
1507		}
1508
1509
1510		/**
1511		* Nonblocking operation request with EPR
1512		* @ingroup RegistryPortType_RenewOp_operation
1513		* Begin sending a request for the <code>RenewOp</code> operation on a
1514		* resource handled by the service named by the @a epr. When the operation
1515		* request has been sent, the @a callback function will be invoked.
1516		*
1517		* @param client_handle
1518		* The @link #RegistryService_client_handle_t client handle @endlink which
1519		* contains the state related to processing this operation.
1520		* @param epr
1521		* Endpoint Reference of the service and resource which will process
1522		* the operation.
1523		* @param input
1524		* Input parameter to the operation.
1525		* @param callback
1526		* Callback function which will be called once the request has been
1527		* sent
1528		* @param callback_arg
1529		* Application-specific pointer which will be passed to the callback.
1530		*/
1531		globus_result_t
1532		RegistryPortType_RenewOp_epr_register_request(
1533		RegistryService_client_handle_t client_handle,
1534		const wsa_EndpointReferenceType * epr,
1535		const wsen_RenewType * input,
1536		RegistryPortType_RenewOp_request_callback_func_t callback,
1537		void * callback_arg)
1538	0	{
1539	0	globus_result_t result = GLOBUS_SUCCESS;
1540
1541	0	globus_assert_string(epr, "NULL EndpointReference");
1542	0	globus_assert_string(epr->Address.base_value,
1543		"NULL EndpointReference Address");
1544
1545	0	result = globus_soap_client_handle_attr_set(
1546		client_handle,
1547		WSADDR_EPR_KEY,
1548		wsa_EndpointReferenceType_info.copy,
1549		wsa_EndpointReferenceType_info.destroy,
1550		(void *) epr);
1551
1552	0	if (result != GLOBUS_SUCCESS)
1553		{
1554	0	goto out;
1555		}
1556
1557	0	result = globus_soap_client_register_request(
1558		client_handle,
1559		epr->Address.base_value,
1560		&RegistryPortType_l_RenewOp_operation,
1561		(void *) input,
1562		callback,
1563		callback_arg);
1564
1565	0	out:
1566	0	return result;
1567		}
1568
1569		/**
1570		* Nonblocking operation request
1571		* @ingroup RegistryPortType_RenewOp_operation
1572		* Begin sending a request for the <code>RenewOp</code> operation to
1573		* the service at @a endpoint. When the operation
1574		* request has been sent, the @a callback function will be invoked.
1575		* @param handle
1576		* The @link #RegistryService_client_handle_t client handle @endlink which
1577		* contains the state related to processing this operation.
1578		* @param endpoint
1579		* URI of the service endpoint to send the request to.
1580		* @param input
1581		* Input parameter to the operation.
1582		* @param callback
1583		* Callback function which will be called once the request has been
1584		* sent
1585		* @param callback_arg
1586		* Application-specific pointer which will be passed to the callback.
1587		*/
1588		globus_result_t
1589		RegistryPortType_RenewOp_register_request(
1590		RegistryService_client_handle_t client_handle,
1591		const char * endpoint,
1592		const wsen_RenewType * input,
1593		RegistryPortType_RenewOp_request_callback_func_t callback,
1594		void * callback_arg)
1595	0	{
1596	0	return globus_soap_client_register_request(
1597		client_handle,
1598		endpoint,
1599		&RegistryPortType_l_RenewOp_operation,
1600		(void *) input,
1601		callback,
1602		callback_arg);
1603		}
1604
1605
1606
1607		static
1608		void
1609		RegistryPortType_l_RenewOp_deserialize_fault(
1610		globus_soap_message_handle_t handle,
1611		const xsd_QName * fault_qname,
1612		int * fault_type)
1613	0	{
1614	0	*fault_type = REGISTRYPORTTYPE_RENEWOP_NOFAULT;
1615
1616	0	if(fault_qname)
1617		{
1618
1619		{
1620	0	*fault_type = REGISTRYPORTTYPE_RENEWOP_UNKNOWN_FAULT;
1621		}
1622		}
1623	0	}
1624		/* RegistryPortType_l_RenewOp_deserialize_fault() */
1625
1626		/**
1627		* Nonblocking operation response handling
1628		* @ingroup RegistryPortType_RenewOp_operation
1629		* Begin parsing the request for the <code>RenewOp</code> operation begun
1630		* by an earlier call to
1631		* RegistryPortType_RenewOp_register_request() or
1632		* RegistryPortType_RenewOp_epr_register_request(). Once the response has been parsed.
1633		* the @a callback function will be called to pass the result of the operation
1634		* to the application.
1635		*
1636		* @param client_handle
1637		* The @link #RegistryService_client_handle_t client handle @endlink which
1638		* contains the state related to processing this operation.
1639		* @param callback
1640		* Callback function which will be called once the response has been
1641		* processed.
1642		* @param callback_arg
1643		* Application-specific pointer which will be passed to the callback.
1644		*/
1645		globus_result_t
1646		RegistryPortType_RenewOp_register_response(
1647		RegistryService_client_handle_t client_handle,
1648		RegistryPortType_RenewOp_response_callback_func_t callback,
1649		void * callback_arg)
1650	0	{
1651	0	return globus_soap_client_register_response(
1652		client_handle,
1653		(globus_soap_client_response_callback_func_t) callback,
1654		callback_arg);
1655		}
1656
1657		/**
1658		* Nonblocking operation invocation with EPR
1659		* @ingroup RegistryPortType_RenewOp_operation
1660		*
1661		* Begin processing a request for the RenewOp operation. The operation will
1662		* sent to the service named by the @a epr and after the response is received,
1663		* the @a callback function will be invoked.
1664		*
1665		* @param handle
1666		* The @link #RegistryService_client_handle_t client handle @endlink which
1667		* contains the state related to processing this operation.
1668		* @param epr
1669		* Endpoint Reference of the service and resource which will process
1670		* the operation.
1671		* @param input
1672		* Input parameter to the operation.
1673		* @param callback
1674		* Callback function which will be called once the operation has been
1675		* processed.
1676		* @param callback_arg
1677		* Application-specific pointer which will be passed to the callback.
1678		*/
1679		globus_result_t
1680		RegistryPortType_RenewOp_epr_register(
1681		RegistryService_client_handle_t handle,
1682		const wsa_EndpointReferenceType * epr,
1683		const wsen_RenewType * input,
1684		RegistryPortType_RenewOp_response_callback_func_t callback,
1685		void * callback_arg)
1686	0	{
1687		globus_result_t result;
1688
1689	0	result = globus_soap_client_handle_attr_set(
1690		handle,
1691		WSADDR_EPR_KEY,
1692		wsa_EndpointReferenceType_info.copy,
1693		wsa_EndpointReferenceType_info.destroy,
1694		(void *) epr);
1695
1696	0	if (result != GLOBUS_SUCCESS)
1697		{
1698	0	goto out;
1699		}
1700
1701	0	result = globus_soap_client_operation_register(
1702		handle,
1703		epr->Address.base_value,
1704		&RegistryPortType_l_RenewOp_operation,
1705		(void *) input,
1706		(globus_soap_client_response_callback_func_t) callback,
1707		callback_arg);
1708	0	out:
1709	0	return result;
1710		}
1711
1712		/**
1713		* Nonblocking operation invocation
1714		* @ingroup RegistryPortType_RenewOp_operation
1715		*
1716		* Begin processing a request for the RenewOp operation. The operation will
1717		* sent to the service located at @a endpoint and after the response is
1718		* received, the @a callback function will be invoked.
1719		*
1720		* @param handle
1721		* The @link #RegistryService_client_handle_t client handle @endlink which
1722		* contains the state related to processing this operation.
1723		* @param endpoint
1724		* URI of the service endpoint to send the request to.
1725		* @param input
1726		* Input parameter to the operation.
1727		* @param callback
1728		* Callback function which will be called once the operation has been
1729		* processed.
1730		* @param callback_arg
1731		* Application-specific pointer which will be passed to the callback.
1732		*/
1733		globus_result_t
1734		RegistryPortType_RenewOp_register(
1735		RegistryService_client_handle_t handle,
1736		const char * endpoint,
1737		const wsen_RenewType * input,
1738		RegistryPortType_RenewOp_response_callback_func_t callback,
1739		void * callback_arg)
1740	0	{
1741	0	return globus_soap_client_operation_register(
1742		handle,
1743		endpoint,
1744		&RegistryPortType_l_RenewOp_operation,
1745		(void *) input,
1746		(globus_soap_client_response_callback_func_t) callback,
1747		callback_arg);
1748		}
1749
1750
1751
1752		/**
1753		* Blocking operation invocation with EPR
1754		* @ingroup RegistryPortType_RenewOp_operation
1755		*
1756		* Request that an the RenewOp operation be invoked by the service and
1757		* resource named by the @a epr parameter.
1758
1759		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1760		* @a output parameter will be set to the result of the operation.
1761		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1762		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1763		* error occurred, and the result's error type should be checked.
1764
1765		*
1766		* @param handle
1767		* The @link #RegistryService_client_handle_t client handle @endlink which
1768		* contains the state related to processing this operation.
1769		* @param epr
1770		* Endpoint Reference of the service and resource which will process
1771		* the operation.
1772		* @param input
1773		* Input parameter to the operation.
1774
1775		* @param output
1776		* The output of the operation, if the operation succeeded.
1777		* @param fault_type
1778		* The type of fault sent as a result of the operation, if the operation
1779		* failed. If the operation succeeded, this will be NULL.
1780		* @param fault
1781		* The fault element which was received, if the operation failed.
1782		* If the operation succeeded, this will be NULL.
1783
1784		*/
1785		globus_result_t
1786		RegistryPortType_RenewOp_epr(
1787		RegistryService_client_handle_t handle,
1788		const wsa_EndpointReferenceType * epr,
1789		const wsen_RenewType * input,
1790		wsen_RenewResponseType * * output,
1791		RegistryPortType_RenewOp_fault_t * fault_type,
1792		xsd_any * * fault)
1793	0	{
1794		globus_result_t result;
1795
1796	0	result = globus_soap_client_handle_attr_set(
1797		handle,
1798		WSADDR_EPR_KEY,
1799		wsa_EndpointReferenceType_info.copy,
1800		wsa_EndpointReferenceType_info.destroy,
1801		(void *) epr);
1802
1803	0	if (result != GLOBUS_SUCCESS)
1804		{
1805	0	goto out;
1806		}
1807	0	result = globus_soap_client_operation(
1808		handle,
1809		epr->Address.base_value,
1810		&RegistryPortType_l_RenewOp_operation,
1811		(void *) input,
1812
1813		(void **) output,
1814		(int *) fault_type,
1815		fault
1816		);
1817	0	out:
1818	0	return result;
1819		}
1820
1821		/**
1822		* Blocking operation invocation
1823		* @ingroup RegistryPortType_RenewOp_operation
1824		*
1825		* Request that an the RenewOp operation be invoked by the service at
1826		* @a endpoint.
1827
1828		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1829		* @a output parameter will be set to the result of the operation.
1830		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1831		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1832		* error occurred, and the result's error type should be checked.
1833
1834		*
1835		* @param handle
1836		* The @link #RegistryService_client_handle_t client handle @endlink which
1837		* contains the state related to processing this operation.
1838		* @param endpoint
1839		* URI of the service endpoint to send the request to.
1840		* @param input
1841		* Input parameter to the operation.
1842
1843		* @param output
1844		* The output of the operation, if the operation succeeded.
1845		* @param fault_type
1846		* The type of fault sent as a result of the operation, if the operation
1847		* failed. If the operation succeeded, this will be NULL.
1848		* @param fault
1849		* The fault element which was received, if the operation failed.
1850		* If the operation succeeded, this will be NULL.
1851
1852		*/
1853		globus_result_t
1854		RegistryPortType_RenewOp(
1855		RegistryService_client_handle_t handle,
1856		const char * endpoint,
1857		const wsen_RenewType * input,
1858		wsen_RenewResponseType * * output,
1859		RegistryPortType_RenewOp_fault_t * fault_type,
1860		xsd_any * * fault)
1861	0	{
1862	0	return globus_soap_client_operation(
1863		handle,
1864		endpoint,
1865		&RegistryPortType_l_RenewOp_operation,
1866		(void *) input,
1867
1868		(void *) output,
1869		(int *) fault_type,
1870		fault
1871		);
1872		}
1873
1874
1875		/**
1876		* Nonblocking operation request with EPR
1877		* @ingroup RegistryPortType_PullOp_operation
1878		* Begin sending a request for the <code>PullOp</code> operation on a
1879		* resource handled by the service named by the @a epr. When the operation
1880		* request has been sent, the @a callback function will be invoked.
1881		*
1882		* @param client_handle
1883		* The @link #RegistryService_client_handle_t client handle @endlink which
1884		* contains the state related to processing this operation.
1885		* @param epr
1886		* Endpoint Reference of the service and resource which will process
1887		* the operation.
1888		* @param input
1889		* Input parameter to the operation.
1890		* @param callback
1891		* Callback function which will be called once the request has been
1892		* sent
1893		* @param callback_arg
1894		* Application-specific pointer which will be passed to the callback.
1895		*/
1896		globus_result_t
1897		RegistryPortType_PullOp_epr_register_request(
1898		RegistryService_client_handle_t client_handle,
1899		const wsa_EndpointReferenceType * epr,
1900		const wsen_PullType * input,
1901		RegistryPortType_PullOp_request_callback_func_t callback,
1902		void * callback_arg)
1903	0	{
1904	0	globus_result_t result = GLOBUS_SUCCESS;
1905
1906	0	globus_assert_string(epr, "NULL EndpointReference");
1907	0	globus_assert_string(epr->Address.base_value,
1908		"NULL EndpointReference Address");
1909
1910	0	result = globus_soap_client_handle_attr_set(
1911		client_handle,
1912		WSADDR_EPR_KEY,
1913		wsa_EndpointReferenceType_info.copy,
1914		wsa_EndpointReferenceType_info.destroy,
1915		(void *) epr);
1916
1917	0	if (result != GLOBUS_SUCCESS)
1918		{
1919	0	goto out;
1920		}
1921
1922	0	result = globus_soap_client_register_request(
1923		client_handle,
1924		epr->Address.base_value,
1925		&RegistryPortType_l_PullOp_operation,
1926		(void *) input,
1927		callback,
1928		callback_arg);
1929
1930	0	out:
1931	0	return result;
1932		}
1933
1934		/**
1935		* Nonblocking operation request
1936		* @ingroup RegistryPortType_PullOp_operation
1937		* Begin sending a request for the <code>PullOp</code> operation to
1938		* the service at @a endpoint. When the operation
1939		* request has been sent, the @a callback function will be invoked.
1940		* @param handle
1941		* The @link #RegistryService_client_handle_t client handle @endlink which
1942		* contains the state related to processing this operation.
1943		* @param endpoint
1944		* URI of the service endpoint to send the request to.
1945		* @param input
1946		* Input parameter to the operation.
1947		* @param callback
1948		* Callback function which will be called once the request has been
1949		* sent
1950		* @param callback_arg
1951		* Application-specific pointer which will be passed to the callback.
1952		*/
1953		globus_result_t
1954		RegistryPortType_PullOp_register_request(
1955		RegistryService_client_handle_t client_handle,
1956		const char * endpoint,
1957		const wsen_PullType * input,
1958		RegistryPortType_PullOp_request_callback_func_t callback,
1959		void * callback_arg)
1960	0	{
1961	0	return globus_soap_client_register_request(
1962		client_handle,
1963		endpoint,
1964		&RegistryPortType_l_PullOp_operation,
1965		(void *) input,
1966		callback,
1967		callback_arg);
1968		}
1969
1970
1971
1972		static
1973		void
1974		RegistryPortType_l_PullOp_deserialize_fault(
1975		globus_soap_message_handle_t handle,
1976		const xsd_QName * fault_qname,
1977		int * fault_type)
1978	0	{
1979	0	*fault_type = REGISTRYPORTTYPE_PULLOP_NOFAULT;
1980
1981	0	if(fault_qname)
1982		{
1983
1984		{
1985	0	*fault_type = REGISTRYPORTTYPE_PULLOP_UNKNOWN_FAULT;
1986		}
1987		}
1988	0	}
1989		/* RegistryPortType_l_PullOp_deserialize_fault() */
1990
1991		/**
1992		* Nonblocking operation response handling
1993		* @ingroup RegistryPortType_PullOp_operation
1994		* Begin parsing the request for the <code>PullOp</code> operation begun
1995		* by an earlier call to
1996		* RegistryPortType_PullOp_register_request() or
1997		* RegistryPortType_PullOp_epr_register_request(). Once the response has been parsed.
1998		* the @a callback function will be called to pass the result of the operation
1999		* to the application.
2000		*
2001		* @param client_handle
2002		* The @link #RegistryService_client_handle_t client handle @endlink which
2003		* contains the state related to processing this operation.
2004		* @param callback
2005		* Callback function which will be called once the response has been
2006		* processed.
2007		* @param callback_arg
2008		* Application-specific pointer which will be passed to the callback.
2009		*/
2010		globus_result_t
2011		RegistryPortType_PullOp_register_response(
2012		RegistryService_client_handle_t client_handle,
2013		RegistryPortType_PullOp_response_callback_func_t callback,
2014		void * callback_arg)
2015	0	{
2016	0	return globus_soap_client_register_response(
2017		client_handle,
2018		(globus_soap_client_response_callback_func_t) callback,
2019		callback_arg);
2020		}
2021
2022		/**
2023		* Nonblocking operation invocation with EPR
2024		* @ingroup RegistryPortType_PullOp_operation
2025		*
2026		* Begin processing a request for the PullOp operation. The operation will
2027		* sent to the service named by the @a epr and after the response is received,
2028		* the @a callback function will be invoked.
2029		*
2030		* @param handle
2031		* The @link #RegistryService_client_handle_t client handle @endlink which
2032		* contains the state related to processing this operation.
2033		* @param epr
2034		* Endpoint Reference of the service and resource which will process
2035		* the operation.
2036		* @param input
2037		* Input parameter to the operation.
2038		* @param callback
2039		* Callback function which will be called once the operation has been
2040		* processed.
2041		* @param callback_arg
2042		* Application-specific pointer which will be passed to the callback.
2043		*/
2044		globus_result_t
2045		RegistryPortType_PullOp_epr_register(
2046		RegistryService_client_handle_t handle,
2047		const wsa_EndpointReferenceType * epr,
2048		const wsen_PullType * input,
2049		RegistryPortType_PullOp_response_callback_func_t callback,
2050		void * callback_arg)
2051	0	{
2052		globus_result_t result;
2053
2054	0	result = globus_soap_client_handle_attr_set(
2055		handle,
2056		WSADDR_EPR_KEY,
2057		wsa_EndpointReferenceType_info.copy,
2058		wsa_EndpointReferenceType_info.destroy,
2059		(void *) epr);
2060
2061	0	if (result != GLOBUS_SUCCESS)
2062		{
2063	0	goto out;
2064		}
2065
2066	0	result = globus_soap_client_operation_register(
2067		handle,
2068		epr->Address.base_value,
2069		&RegistryPortType_l_PullOp_operation,
2070		(void *) input,
2071		(globus_soap_client_response_callback_func_t) callback,
2072		callback_arg);
2073	0	out:
2074	0	return result;
2075		}
2076
2077		/**
2078		* Nonblocking operation invocation
2079		* @ingroup RegistryPortType_PullOp_operation
2080		*
2081		* Begin processing a request for the PullOp operation. The operation will
2082		* sent to the service located at @a endpoint and after the response is
2083		* received, the @a callback function will be invoked.
2084		*
2085		* @param handle
2086		* The @link #RegistryService_client_handle_t client handle @endlink which
2087		* contains the state related to processing this operation.
2088		* @param endpoint
2089		* URI of the service endpoint to send the request to.
2090		* @param input
2091		* Input parameter to the operation.
2092		* @param callback
2093		* Callback function which will be called once the operation has been
2094		* processed.
2095		* @param callback_arg
2096		* Application-specific pointer which will be passed to the callback.
2097		*/
2098		globus_result_t
2099		RegistryPortType_PullOp_register(
2100		RegistryService_client_handle_t handle,
2101		const char * endpoint,
2102		const wsen_PullType * input,
2103		RegistryPortType_PullOp_response_callback_func_t callback,
2104		void * callback_arg)
2105	0	{
2106	0	return globus_soap_client_operation_register(
2107		handle,
2108		endpoint,
2109		&RegistryPortType_l_PullOp_operation,
2110		(void *) input,
2111		(globus_soap_client_response_callback_func_t) callback,
2112		callback_arg);
2113		}
2114
2115
2116
2117		/**
2118		* Blocking operation invocation with EPR
2119		* @ingroup RegistryPortType_PullOp_operation
2120		*
2121		* Request that an the PullOp operation be invoked by the service and
2122		* resource named by the @a epr parameter.
2123
2124		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2125		* @a output parameter will be set to the result of the operation.
2126		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2127		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2128		* error occurred, and the result's error type should be checked.
2129
2130		*
2131		* @param handle
2132		* The @link #RegistryService_client_handle_t client handle @endlink which
2133		* contains the state related to processing this operation.
2134		* @param epr
2135		* Endpoint Reference of the service and resource which will process
2136		* the operation.
2137		* @param input
2138		* Input parameter to the operation.
2139
2140		* @param output
2141		* The output of the operation, if the operation succeeded.
2142		* @param fault_type
2143		* The type of fault sent as a result of the operation, if the operation
2144		* failed. If the operation succeeded, this will be NULL.
2145		* @param fault
2146		* The fault element which was received, if the operation failed.
2147		* If the operation succeeded, this will be NULL.
2148
2149		*/
2150		globus_result_t
2151		RegistryPortType_PullOp_epr(
2152		RegistryService_client_handle_t handle,
2153		const wsa_EndpointReferenceType * epr,
2154		const wsen_PullType * input,
2155		wsen_PullResponseType * * output,
2156		RegistryPortType_PullOp_fault_t * fault_type,
2157		xsd_any * * fault)
2158	0	{
2159		globus_result_t result;
2160
2161	0	result = globus_soap_client_handle_attr_set(
2162		handle,
2163		WSADDR_EPR_KEY,
2164		wsa_EndpointReferenceType_info.copy,
2165		wsa_EndpointReferenceType_info.destroy,
2166		(void *) epr);
2167
2168	0	if (result != GLOBUS_SUCCESS)
2169		{
2170	0	goto out;
2171		}
2172	0	result = globus_soap_client_operation(
2173		handle,
2174		epr->Address.base_value,
2175		&RegistryPortType_l_PullOp_operation,
2176		(void *) input,
2177
2178		(void **) output,
2179		(int *) fault_type,
2180		fault
2181		);
2182	0	out:
2183	0	return result;
2184		}
2185
2186		/**
2187		* Blocking operation invocation
2188		* @ingroup RegistryPortType_PullOp_operation
2189		*
2190		* Request that an the PullOp operation be invoked by the service at
2191		* @a endpoint.
2192
2193		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2194		* @a output parameter will be set to the result of the operation.
2195		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2196		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2197		* error occurred, and the result's error type should be checked.
2198
2199		*
2200		* @param handle
2201		* The @link #RegistryService_client_handle_t client handle @endlink which
2202		* contains the state related to processing this operation.
2203		* @param endpoint
2204		* URI of the service endpoint to send the request to.
2205		* @param input
2206		* Input parameter to the operation.
2207
2208		* @param output
2209		* The output of the operation, if the operation succeeded.
2210		* @param fault_type
2211		* The type of fault sent as a result of the operation, if the operation
2212		* failed. If the operation succeeded, this will be NULL.
2213		* @param fault
2214		* The fault element which was received, if the operation failed.
2215		* If the operation succeeded, this will be NULL.
2216
2217		*/
2218		globus_result_t
2219		RegistryPortType_PullOp(
2220		RegistryService_client_handle_t handle,
2221		const char * endpoint,
2222		const wsen_PullType * input,
2223		wsen_PullResponseType * * output,
2224		RegistryPortType_PullOp_fault_t * fault_type,
2225		xsd_any * * fault)
2226	0	{
2227	0	return globus_soap_client_operation(
2228		handle,
2229		endpoint,
2230		&RegistryPortType_l_PullOp_operation,
2231		(void *) input,
2232
2233		(void *) output,
2234		(int *) fault_type,
2235		fault
2236		);
2237		}
2238
2239
2240		/**
2241		* Nonblocking operation request with EPR
2242		* @ingroup RegistryPortType_GetMultipleResourceProperties_operation
2243		* Begin sending a request for the <code>GetMultipleResourceProperties</code> operation on a
2244		* resource handled by the service named by the @a epr. When the operation
2245		* request has been sent, the @a callback function will be invoked.
2246		*
2247		* @param client_handle
2248		* The @link #RegistryService_client_handle_t client handle @endlink which
2249		* contains the state related to processing this operation.
2250		* @param epr
2251		* Endpoint Reference of the service and resource which will process
2252		* the operation.
2253		* @param input
2254		* Input parameter to the operation.
2255		* @param callback
2256		* Callback function which will be called once the request has been
2257		* sent
2258		* @param callback_arg
2259		* Application-specific pointer which will be passed to the callback.
2260		*/
2261		globus_result_t
2262		RegistryPortType_GetMultipleResourceProperties_epr_register_request(
2263		RegistryService_client_handle_t client_handle,
2264		const wsa_EndpointReferenceType * epr,
2265		const wsrp_GetMultipleResourcePropertiesType * input,
2266		RegistryPortType_GetMultipleResourceProperties_request_callback_func_t callback,
2267		void * callback_arg)
2268	0	{
2269	0	globus_result_t result = GLOBUS_SUCCESS;
2270
2271	0	globus_assert_string(epr, "NULL EndpointReference");
2272	0	globus_assert_string(epr->Address.base_value,
2273		"NULL EndpointReference Address");
2274
2275	0	result = globus_soap_client_handle_attr_set(
2276		client_handle,
2277		WSADDR_EPR_KEY,
2278		wsa_EndpointReferenceType_info.copy,
2279		wsa_EndpointReferenceType_info.destroy,
2280		(void *) epr);
2281
2282	0	if (result != GLOBUS_SUCCESS)
2283		{
2284	0	goto out;
2285		}
2286
2287	0	result = globus_soap_client_register_request(
2288		client_handle,
2289		epr->Address.base_value,
2290		&RegistryPortType_l_GetMultipleResourceProperties_operation,
2291		(void *) input,
2292		callback,
2293		callback_arg);
2294
2295	0	out:
2296	0	return result;
2297		}
2298
2299		/**
2300		* Nonblocking operation request
2301		* @ingroup RegistryPortType_GetMultipleResourceProperties_operation
2302		* Begin sending a request for the <code>GetMultipleResourceProperties</code> operation to
2303		* the service at @a endpoint. When the operation
2304		* request has been sent, the @a callback function will be invoked.
2305		* @param handle
2306		* The @link #RegistryService_client_handle_t client handle @endlink which
2307		* contains the state related to processing this operation.
2308		* @param endpoint
2309		* URI of the service endpoint to send the request to.
2310		* @param input
2311		* Input parameter to the operation.
2312		* @param callback
2313		* Callback function which will be called once the request has been
2314		* sent
2315		* @param callback_arg
2316		* Application-specific pointer which will be passed to the callback.
2317		*/
2318		globus_result_t
2319		RegistryPortType_GetMultipleResourceProperties_register_request(
2320		RegistryService_client_handle_t client_handle,
2321		const char * endpoint,
2322		const wsrp_GetMultipleResourcePropertiesType * input,
2323		RegistryPortType_GetMultipleResourceProperties_request_callback_func_t callback,
2324		void * callback_arg)
2325	0	{
2326	0	return globus_soap_client_register_request(
2327		client_handle,
2328		endpoint,
2329		&RegistryPortType_l_GetMultipleResourceProperties_operation,
2330		(void *) input,
2331		callback,
2332		callback_arg);
2333		}
2334
2335
2336
2337		static
2338		void
2339		RegistryPortType_l_GetMultipleResourceProperties_deserialize_fault(
2340		globus_soap_message_handle_t handle,
2341		const xsd_QName * fault_qname,
2342		int * fault_type)
2343	0	{
2344	0	*fault_type = REGISTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_NOFAULT;
2345
2346	0	if(fault_qname)
2347		{
2348	0	if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
2349		fault_qname == (&wsr_ResourceUnknownFault_qname))
2350		{
2351	0	*fault_type = REGISTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_RESOURCEUNKNOWNFAULT;
2352		}
2353	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
2354		fault_qname == (&wsr_ResourceUnavailableFault_qname))
2355		{
2356	0	*fault_type = REGISTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_RESOURCEUNAVAILABLEFAULT;
2357		}
2358	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
2359		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
2360		{
2361	0	*fault_type = REGISTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_INVALIDRESOURCEPROPERTYQNAMEFAULT;
2362		}
2363		else
2364		{
2365	0	*fault_type = REGISTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_UNKNOWN_FAULT;
2366		}
2367		}
2368	0	}
2369		/* RegistryPortType_l_GetMultipleResourceProperties_deserialize_fault() */
2370
2371		/**
2372		* Nonblocking operation response handling
2373		* @ingroup RegistryPortType_GetMultipleResourceProperties_operation
2374		* Begin parsing the request for the <code>GetMultipleResourceProperties</code> operation begun
2375		* by an earlier call to
2376		* RegistryPortType_GetMultipleResourceProperties_register_request() or
2377		* RegistryPortType_GetMultipleResourceProperties_epr_register_request(). Once the response has been parsed.
2378		* the @a callback function will be called to pass the result of the operation
2379		* to the application.
2380		*
2381		* @param client_handle
2382		* The @link #RegistryService_client_handle_t client handle @endlink which
2383		* contains the state related to processing this operation.
2384		* @param callback
2385		* Callback function which will be called once the response has been
2386		* processed.
2387		* @param callback_arg
2388		* Application-specific pointer which will be passed to the callback.
2389		*/
2390		globus_result_t
2391		RegistryPortType_GetMultipleResourceProperties_register_response(
2392		RegistryService_client_handle_t client_handle,
2393		RegistryPortType_GetMultipleResourceProperties_response_callback_func_t callback,
2394		void * callback_arg)
2395	0	{
2396	0	return globus_soap_client_register_response(
2397		client_handle,
2398		(globus_soap_client_response_callback_func_t) callback,
2399		callback_arg);
2400		}
2401
2402		/**
2403		* Nonblocking operation invocation with EPR
2404		* @ingroup RegistryPortType_GetMultipleResourceProperties_operation
2405		*
2406		* Begin processing a request for the GetMultipleResourceProperties operation. The operation will
2407		* sent to the service named by the @a epr and after the response is received,
2408		* the @a callback function will be invoked.
2409		*
2410		* @param handle
2411		* The @link #RegistryService_client_handle_t client handle @endlink which
2412		* contains the state related to processing this operation.
2413		* @param epr
2414		* Endpoint Reference of the service and resource which will process
2415		* the operation.
2416		* @param input
2417		* Input parameter to the operation.
2418		* @param callback
2419		* Callback function which will be called once the operation has been
2420		* processed.
2421		* @param callback_arg
2422		* Application-specific pointer which will be passed to the callback.
2423		*/
2424		globus_result_t
2425		RegistryPortType_GetMultipleResourceProperties_epr_register(
2426		RegistryService_client_handle_t handle,
2427		const wsa_EndpointReferenceType * epr,
2428		const wsrp_GetMultipleResourcePropertiesType * input,
2429		RegistryPortType_GetMultipleResourceProperties_response_callback_func_t callback,
2430		void * callback_arg)
2431	0	{
2432		globus_result_t result;
2433
2434	0	result = globus_soap_client_handle_attr_set(
2435		handle,
2436		WSADDR_EPR_KEY,
2437		wsa_EndpointReferenceType_info.copy,
2438		wsa_EndpointReferenceType_info.destroy,
2439		(void *) epr);
2440
2441	0	if (result != GLOBUS_SUCCESS)
2442		{
2443	0	goto out;
2444		}
2445
2446	0	result = globus_soap_client_operation_register(
2447		handle,
2448		epr->Address.base_value,
2449		&RegistryPortType_l_GetMultipleResourceProperties_operation,
2450		(void *) input,
2451		(globus_soap_client_response_callback_func_t) callback,
2452		callback_arg);
2453	0	out:
2454	0	return result;
2455		}
2456
2457		/**
2458		* Nonblocking operation invocation
2459		* @ingroup RegistryPortType_GetMultipleResourceProperties_operation
2460		*
2461		* Begin processing a request for the GetMultipleResourceProperties operation. The operation will
2462		* sent to the service located at @a endpoint and after the response is
2463		* received, the @a callback function will be invoked.
2464		*
2465		* @param handle
2466		* The @link #RegistryService_client_handle_t client handle @endlink which
2467		* contains the state related to processing this operation.
2468		* @param endpoint
2469		* URI of the service endpoint to send the request to.
2470		* @param input
2471		* Input parameter to the operation.
2472		* @param callback
2473		* Callback function which will be called once the operation has been
2474		* processed.
2475		* @param callback_arg
2476		* Application-specific pointer which will be passed to the callback.
2477		*/
2478		globus_result_t
2479		RegistryPortType_GetMultipleResourceProperties_register(
2480		RegistryService_client_handle_t handle,
2481		const char * endpoint,
2482		const wsrp_GetMultipleResourcePropertiesType * input,
2483		RegistryPortType_GetMultipleResourceProperties_response_callback_func_t callback,
2484		void * callback_arg)
2485	0	{
2486	0	return globus_soap_client_operation_register(
2487		handle,
2488		endpoint,
2489		&RegistryPortType_l_GetMultipleResourceProperties_operation,
2490		(void *) input,
2491		(globus_soap_client_response_callback_func_t) callback,
2492		callback_arg);
2493		}
2494
2495
2496
2497		/**
2498		* Blocking operation invocation with EPR
2499		* @ingroup RegistryPortType_GetMultipleResourceProperties_operation
2500		*
2501		* Request that an the GetMultipleResourceProperties operation be invoked by the service and
2502		* resource named by the @a epr parameter.
2503
2504		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2505		* @a output parameter will be set to the result of the operation.
2506		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2507		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2508		* error occurred, and the result's error type should be checked.
2509
2510		*
2511		* @param handle
2512		* The @link #RegistryService_client_handle_t client handle @endlink which
2513		* contains the state related to processing this operation.
2514		* @param epr
2515		* Endpoint Reference of the service and resource which will process
2516		* the operation.
2517		* @param input
2518		* Input parameter to the operation.
2519
2520		* @param output
2521		* The output of the operation, if the operation succeeded.
2522		* @param fault_type
2523		* The type of fault sent as a result of the operation, if the operation
2524		* failed. If the operation succeeded, this will be NULL.
2525		* @param fault
2526		* The fault element which was received, if the operation failed.
2527		* If the operation succeeded, this will be NULL.
2528
2529		*/
2530		globus_result_t
2531		RegistryPortType_GetMultipleResourceProperties_epr(
2532		RegistryService_client_handle_t handle,
2533		const wsa_EndpointReferenceType * epr,
2534		const wsrp_GetMultipleResourcePropertiesType * input,
2535		wsrp_GetMultipleResourcePropertiesResponseType * * output,
2536		RegistryPortType_GetMultipleResourceProperties_fault_t * fault_type,
2537		xsd_any * * fault)
2538	0	{
2539		globus_result_t result;
2540
2541	0	result = globus_soap_client_handle_attr_set(
2542		handle,
2543		WSADDR_EPR_KEY,
2544		wsa_EndpointReferenceType_info.copy,
2545		wsa_EndpointReferenceType_info.destroy,
2546		(void *) epr);
2547
2548	0	if (result != GLOBUS_SUCCESS)
2549		{
2550	0	goto out;
2551		}
2552	0	result = globus_soap_client_operation(
2553		handle,
2554		epr->Address.base_value,
2555		&RegistryPortType_l_GetMultipleResourceProperties_operation,
2556		(void *) input,
2557
2558		(void **) output,
2559		(int *) fault_type,
2560		fault
2561		);
2562	0	out:
2563	0	return result;
2564		}
2565
2566		/**
2567		* Blocking operation invocation
2568		* @ingroup RegistryPortType_GetMultipleResourceProperties_operation
2569		*
2570		* Request that an the GetMultipleResourceProperties operation be invoked by the service at
2571		* @a endpoint.
2572
2573		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2574		* @a output parameter will be set to the result of the operation.
2575		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2576		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2577		* error occurred, and the result's error type should be checked.
2578
2579		*
2580		* @param handle
2581		* The @link #RegistryService_client_handle_t client handle @endlink which
2582		* contains the state related to processing this operation.
2583		* @param endpoint
2584		* URI of the service endpoint to send the request to.
2585		* @param input
2586		* Input parameter to the operation.
2587
2588		* @param output
2589		* The output of the operation, if the operation succeeded.
2590		* @param fault_type
2591		* The type of fault sent as a result of the operation, if the operation
2592		* failed. If the operation succeeded, this will be NULL.
2593		* @param fault
2594		* The fault element which was received, if the operation failed.
2595		* If the operation succeeded, this will be NULL.
2596
2597		*/
2598		globus_result_t
2599		RegistryPortType_GetMultipleResourceProperties(
2600		RegistryService_client_handle_t handle,
2601		const char * endpoint,
2602		const wsrp_GetMultipleResourcePropertiesType * input,
2603		wsrp_GetMultipleResourcePropertiesResponseType * * output,
2604		RegistryPortType_GetMultipleResourceProperties_fault_t * fault_type,
2605		xsd_any * * fault)
2606	0	{
2607	0	return globus_soap_client_operation(
2608		handle,
2609		endpoint,
2610		&RegistryPortType_l_GetMultipleResourceProperties_operation,
2611		(void *) input,
2612
2613		(void *) output,
2614		(int *) fault_type,
2615		fault
2616		);
2617		}
2618
2619
2620		/**
2621		* Nonblocking operation request with EPR
2622		* @ingroup RegistryPortType_QueryResourceProperties_operation
2623		* Begin sending a request for the <code>QueryResourceProperties</code> operation on a
2624		* resource handled by the service named by the @a epr. When the operation
2625		* request has been sent, the @a callback function will be invoked.
2626		*
2627		* @param client_handle
2628		* The @link #RegistryService_client_handle_t client handle @endlink which
2629		* contains the state related to processing this operation.
2630		* @param epr
2631		* Endpoint Reference of the service and resource which will process
2632		* the operation.
2633		* @param input
2634		* Input parameter to the operation.
2635		* @param callback
2636		* Callback function which will be called once the request has been
2637		* sent
2638		* @param callback_arg
2639		* Application-specific pointer which will be passed to the callback.
2640		*/
2641		globus_result_t
2642		RegistryPortType_QueryResourceProperties_epr_register_request(
2643		RegistryService_client_handle_t client_handle,
2644		const wsa_EndpointReferenceType * epr,
2645		const wsrp_QueryResourcePropertiesType * input,
2646		RegistryPortType_QueryResourceProperties_request_callback_func_t callback,
2647		void * callback_arg)
2648	0	{
2649	0	globus_result_t result = GLOBUS_SUCCESS;
2650
2651	0	globus_assert_string(epr, "NULL EndpointReference");
2652	0	globus_assert_string(epr->Address.base_value,
2653		"NULL EndpointReference Address");
2654
2655	0	result = globus_soap_client_handle_attr_set(
2656		client_handle,
2657		WSADDR_EPR_KEY,
2658		wsa_EndpointReferenceType_info.copy,
2659		wsa_EndpointReferenceType_info.destroy,
2660		(void *) epr);
2661
2662	0	if (result != GLOBUS_SUCCESS)
2663		{
2664	0	goto out;
2665		}
2666
2667	0	result = globus_soap_client_register_request(
2668		client_handle,
2669		epr->Address.base_value,
2670		&RegistryPortType_l_QueryResourceProperties_operation,
2671		(void *) input,
2672		callback,
2673		callback_arg);
2674
2675	0	out:
2676	0	return result;
2677		}
2678
2679		/**
2680		* Nonblocking operation request
2681		* @ingroup RegistryPortType_QueryResourceProperties_operation
2682		* Begin sending a request for the <code>QueryResourceProperties</code> operation to
2683		* the service at @a endpoint. When the operation
2684		* request has been sent, the @a callback function will be invoked.
2685		* @param handle
2686		* The @link #RegistryService_client_handle_t client handle @endlink which
2687		* contains the state related to processing this operation.
2688		* @param endpoint
2689		* URI of the service endpoint to send the request to.
2690		* @param input
2691		* Input parameter to the operation.
2692		* @param callback
2693		* Callback function which will be called once the request has been
2694		* sent
2695		* @param callback_arg
2696		* Application-specific pointer which will be passed to the callback.
2697		*/
2698		globus_result_t
2699		RegistryPortType_QueryResourceProperties_register_request(
2700		RegistryService_client_handle_t client_handle,
2701		const char * endpoint,
2702		const wsrp_QueryResourcePropertiesType * input,
2703		RegistryPortType_QueryResourceProperties_request_callback_func_t callback,
2704		void * callback_arg)
2705	0	{
2706	0	return globus_soap_client_register_request(
2707		client_handle,
2708		endpoint,
2709		&RegistryPortType_l_QueryResourceProperties_operation,
2710		(void *) input,
2711		callback,
2712		callback_arg);
2713		}
2714
2715
2716
2717		static
2718		void
2719		RegistryPortType_l_QueryResourceProperties_deserialize_fault(
2720		globus_soap_message_handle_t handle,
2721		const xsd_QName * fault_qname,
2722		int * fault_type)
2723	0	{
2724	0	*fault_type = REGISTRYPORTTYPE_QUERYRESOURCEPROPERTIES_NOFAULT;
2725
2726	0	if(fault_qname)
2727		{
2728	0	if(fault_qname == (&wsrp_UnknownQueryExpressionDialectFaultType_qname) ||
2729		fault_qname == (&wsrp_UnknownQueryExpressionDialectFault_qname))
2730		{
2731	0	*fault_type = REGISTRYPORTTYPE_QUERYRESOURCEPROPERTIES_UNKNOWNQUERYEXPRESSIONDIALECTFAULT;
2732		}
2733	0	else if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
2734		fault_qname == (&wsr_ResourceUnknownFault_qname))
2735		{
2736	0	*fault_type = REGISTRYPORTTYPE_QUERYRESOURCEPROPERTIES_RESOURCEUNKNOWNFAULT;
2737		}
2738	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
2739		fault_qname == (&wsr_ResourceUnavailableFault_qname))
2740		{
2741	0	*fault_type = REGISTRYPORTTYPE_QUERYRESOURCEPROPERTIES_RESOURCEUNAVAILABLEFAULT;
2742		}
2743	0	else if(fault_qname == (&wsrp_QueryEvaluationErrorFaultType_qname) ||
2744		fault_qname == (&wsrp_QueryEvaluationErrorFault_qname))
2745		{
2746	0	*fault_type = REGISTRYPORTTYPE_QUERYRESOURCEPROPERTIES_QUERYEVALUATIONERRORFAULT;
2747		}
2748	0	else if(fault_qname == (&wsrp_InvalidQueryExpressionFaultType_qname) ||
2749		fault_qname == (&wsrp_InvalidQueryExpressionFault_qname))
2750		{
2751	0	*fault_type = REGISTRYPORTTYPE_QUERYRESOURCEPROPERTIES_INVALIDQUERYEXPRESSIONFAULT;
2752		}
2753	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
2754		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
2755		{
2756	0	*fault_type = REGISTRYPORTTYPE_QUERYRESOURCEPROPERTIES_INVALIDRESOURCEPROPERTYQNAMEFAULT;
2757		}
2758		else
2759		{
2760	0	*fault_type = REGISTRYPORTTYPE_QUERYRESOURCEPROPERTIES_UNKNOWN_FAULT;
2761		}
2762		}
2763	0	}
2764		/* RegistryPortType_l_QueryResourceProperties_deserialize_fault() */
2765
2766		/**
2767		* Nonblocking operation response handling
2768		* @ingroup RegistryPortType_QueryResourceProperties_operation
2769		* Begin parsing the request for the <code>QueryResourceProperties</code> operation begun
2770		* by an earlier call to
2771		* RegistryPortType_QueryResourceProperties_register_request() or
2772		* RegistryPortType_QueryResourceProperties_epr_register_request(). Once the response has been parsed.
2773		* the @a callback function will be called to pass the result of the operation
2774		* to the application.
2775		*
2776		* @param client_handle
2777		* The @link #RegistryService_client_handle_t client handle @endlink which
2778		* contains the state related to processing this operation.
2779		* @param callback
2780		* Callback function which will be called once the response has been
2781		* processed.
2782		* @param callback_arg
2783		* Application-specific pointer which will be passed to the callback.
2784		*/
2785		globus_result_t
2786		RegistryPortType_QueryResourceProperties_register_response(
2787		RegistryService_client_handle_t client_handle,
2788		RegistryPortType_QueryResourceProperties_response_callback_func_t callback,
2789		void * callback_arg)
2790	0	{
2791	0	return globus_soap_client_register_response(
2792		client_handle,
2793		(globus_soap_client_response_callback_func_t) callback,
2794		callback_arg);
2795		}
2796
2797		/**
2798		* Nonblocking operation invocation with EPR
2799		* @ingroup RegistryPortType_QueryResourceProperties_operation
2800		*
2801		* Begin processing a request for the QueryResourceProperties operation. The operation will
2802		* sent to the service named by the @a epr and after the response is received,
2803		* the @a callback function will be invoked.
2804		*
2805		* @param handle
2806		* The @link #RegistryService_client_handle_t client handle @endlink which
2807		* contains the state related to processing this operation.
2808		* @param epr
2809		* Endpoint Reference of the service and resource which will process
2810		* the operation.
2811		* @param input
2812		* Input parameter to the operation.
2813		* @param callback
2814		* Callback function which will be called once the operation has been
2815		* processed.
2816		* @param callback_arg
2817		* Application-specific pointer which will be passed to the callback.
2818		*/
2819		globus_result_t
2820		RegistryPortType_QueryResourceProperties_epr_register(
2821		RegistryService_client_handle_t handle,
2822		const wsa_EndpointReferenceType * epr,
2823		const wsrp_QueryResourcePropertiesType * input,
2824		RegistryPortType_QueryResourceProperties_response_callback_func_t callback,
2825		void * callback_arg)
2826	0	{
2827		globus_result_t result;
2828
2829	0	result = globus_soap_client_handle_attr_set(
2830		handle,
2831		WSADDR_EPR_KEY,
2832		wsa_EndpointReferenceType_info.copy,
2833		wsa_EndpointReferenceType_info.destroy,
2834		(void *) epr);
2835
2836	0	if (result != GLOBUS_SUCCESS)
2837		{
2838	0	goto out;
2839		}
2840
2841	0	result = globus_soap_client_operation_register(
2842		handle,
2843		epr->Address.base_value,
2844		&RegistryPortType_l_QueryResourceProperties_operation,
2845		(void *) input,
2846		(globus_soap_client_response_callback_func_t) callback,
2847		callback_arg);
2848	0	out:
2849	0	return result;
2850		}
2851
2852		/**
2853		* Nonblocking operation invocation
2854		* @ingroup RegistryPortType_QueryResourceProperties_operation
2855		*
2856		* Begin processing a request for the QueryResourceProperties operation. The operation will
2857		* sent to the service located at @a endpoint and after the response is
2858		* received, the @a callback function will be invoked.
2859		*
2860		* @param handle
2861		* The @link #RegistryService_client_handle_t client handle @endlink which
2862		* contains the state related to processing this operation.
2863		* @param endpoint
2864		* URI of the service endpoint to send the request to.
2865		* @param input
2866		* Input parameter to the operation.
2867		* @param callback
2868		* Callback function which will be called once the operation has been
2869		* processed.
2870		* @param callback_arg
2871		* Application-specific pointer which will be passed to the callback.
2872		*/
2873		globus_result_t
2874		RegistryPortType_QueryResourceProperties_register(
2875		RegistryService_client_handle_t handle,
2876		const char * endpoint,
2877		const wsrp_QueryResourcePropertiesType * input,
2878		RegistryPortType_QueryResourceProperties_response_callback_func_t callback,
2879		void * callback_arg)
2880	0	{
2881	0	return globus_soap_client_operation_register(
2882		handle,
2883		endpoint,
2884		&RegistryPortType_l_QueryResourceProperties_operation,
2885		(void *) input,
2886		(globus_soap_client_response_callback_func_t) callback,
2887		callback_arg);
2888		}
2889
2890
2891
2892		/**
2893		* Blocking operation invocation with EPR
2894		* @ingroup RegistryPortType_QueryResourceProperties_operation
2895		*
2896		* Request that an the QueryResourceProperties operation be invoked by the service and
2897		* resource named by the @a epr parameter.
2898
2899		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2900		* @a output parameter will be set to the result of the operation.
2901		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2902		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2903		* error occurred, and the result's error type should be checked.
2904
2905		*
2906		* @param handle
2907		* The @link #RegistryService_client_handle_t client handle @endlink which
2908		* contains the state related to processing this operation.
2909		* @param epr
2910		* Endpoint Reference of the service and resource which will process
2911		* the operation.
2912		* @param input
2913		* Input parameter to the operation.
2914
2915		* @param output
2916		* The output of the operation, if the operation succeeded.
2917		* @param fault_type
2918		* The type of fault sent as a result of the operation, if the operation
2919		* failed. If the operation succeeded, this will be NULL.
2920		* @param fault
2921		* The fault element which was received, if the operation failed.
2922		* If the operation succeeded, this will be NULL.
2923
2924		*/
2925		globus_result_t
2926		RegistryPortType_QueryResourceProperties_epr(
2927		RegistryService_client_handle_t handle,
2928		const wsa_EndpointReferenceType * epr,
2929		const wsrp_QueryResourcePropertiesType * input,
2930		wsrp_QueryResourcePropertiesResponseType * * output,
2931		RegistryPortType_QueryResourceProperties_fault_t * fault_type,
2932		xsd_any * * fault)
2933	0	{
2934		globus_result_t result;
2935
2936	0	result = globus_soap_client_handle_attr_set(
2937		handle,
2938		WSADDR_EPR_KEY,
2939		wsa_EndpointReferenceType_info.copy,
2940		wsa_EndpointReferenceType_info.destroy,
2941		(void *) epr);
2942
2943	0	if (result != GLOBUS_SUCCESS)
2944		{
2945	0	goto out;
2946		}
2947	0	result = globus_soap_client_operation(
2948		handle,
2949		epr->Address.base_value,
2950		&RegistryPortType_l_QueryResourceProperties_operation,
2951		(void *) input,
2952
2953		(void **) output,
2954		(int *) fault_type,
2955		fault
2956		);
2957	0	out:
2958	0	return result;
2959		}
2960
2961		/**
2962		* Blocking operation invocation
2963		* @ingroup RegistryPortType_QueryResourceProperties_operation
2964		*
2965		* Request that an the QueryResourceProperties operation be invoked by the service at
2966		* @a endpoint.
2967
2968		* If the result is <code>GLOBUS_SUCCESS</code>, then the
2969		* @a output parameter will be set to the result of the operation.
2970		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
2971		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
2972		* error occurred, and the result's error type should be checked.
2973
2974		*
2975		* @param handle
2976		* The @link #RegistryService_client_handle_t client handle @endlink which
2977		* contains the state related to processing this operation.
2978		* @param endpoint
2979		* URI of the service endpoint to send the request to.
2980		* @param input
2981		* Input parameter to the operation.
2982
2983		* @param output
2984		* The output of the operation, if the operation succeeded.
2985		* @param fault_type
2986		* The type of fault sent as a result of the operation, if the operation
2987		* failed. If the operation succeeded, this will be NULL.
2988		* @param fault
2989		* The fault element which was received, if the operation failed.
2990		* If the operation succeeded, this will be NULL.
2991
2992		*/
2993		globus_result_t
2994		RegistryPortType_QueryResourceProperties(
2995		RegistryService_client_handle_t handle,
2996		const char * endpoint,
2997		const wsrp_QueryResourcePropertiesType * input,
2998		wsrp_QueryResourcePropertiesResponseType * * output,
2999		RegistryPortType_QueryResourceProperties_fault_t * fault_type,
3000		xsd_any * * fault)
3001	0	{
3002	0	return globus_soap_client_operation(
3003		handle,
3004		endpoint,
3005		&RegistryPortType_l_QueryResourceProperties_operation,
3006		(void *) input,
3007
3008		(void *) output,
3009		(int *) fault_type,
3010		fault
3011		);
3012		}
3013
3014
3015		/**
3016		* Nonblocking operation request with EPR
3017		* @ingroup RegistryPortType_GetResourceProperty_operation
3018		* Begin sending a request for the <code>GetResourceProperty</code> operation on a
3019		* resource handled by the service named by the @a epr. When the operation
3020		* request has been sent, the @a callback function will be invoked.
3021		*
3022		* @param client_handle
3023		* The @link #RegistryService_client_handle_t client handle @endlink which
3024		* contains the state related to processing this operation.
3025		* @param epr
3026		* Endpoint Reference of the service and resource which will process
3027		* the operation.
3028		* @param input
3029		* Input parameter to the operation.
3030		* @param callback
3031		* Callback function which will be called once the request has been
3032		* sent
3033		* @param callback_arg
3034		* Application-specific pointer which will be passed to the callback.
3035		*/
3036		globus_result_t
3037		RegistryPortType_GetResourceProperty_epr_register_request(
3038		RegistryService_client_handle_t client_handle,
3039		const wsa_EndpointReferenceType * epr,
3040		const xsd_QName * input,
3041		RegistryPortType_GetResourceProperty_request_callback_func_t callback,
3042		void * callback_arg)
3043	0	{
3044	0	globus_result_t result = GLOBUS_SUCCESS;
3045
3046	0	globus_assert_string(epr, "NULL EndpointReference");
3047	0	globus_assert_string(epr->Address.base_value,
3048		"NULL EndpointReference Address");
3049
3050	0	result = globus_soap_client_handle_attr_set(
3051		client_handle,
3052		WSADDR_EPR_KEY,
3053		wsa_EndpointReferenceType_info.copy,
3054		wsa_EndpointReferenceType_info.destroy,
3055		(void *) epr);
3056
3057	0	if (result != GLOBUS_SUCCESS)
3058		{
3059	0	goto out;
3060		}
3061
3062	0	result = globus_soap_client_register_request(
3063		client_handle,
3064		epr->Address.base_value,
3065		&RegistryPortType_l_GetResourceProperty_operation,
3066		(void *) input,
3067		callback,
3068		callback_arg);
3069
3070	0	out:
3071	0	return result;
3072		}
3073
3074		/**
3075		* Nonblocking operation request
3076		* @ingroup RegistryPortType_GetResourceProperty_operation
3077		* Begin sending a request for the <code>GetResourceProperty</code> operation to
3078		* the service at @a endpoint. When the operation
3079		* request has been sent, the @a callback function will be invoked.
3080		* @param handle
3081		* The @link #RegistryService_client_handle_t client handle @endlink which
3082		* contains the state related to processing this operation.
3083		* @param endpoint
3084		* URI of the service endpoint to send the request to.
3085		* @param input
3086		* Input parameter to the operation.
3087		* @param callback
3088		* Callback function which will be called once the request has been
3089		* sent
3090		* @param callback_arg
3091		* Application-specific pointer which will be passed to the callback.
3092		*/
3093		globus_result_t
3094		RegistryPortType_GetResourceProperty_register_request(
3095		RegistryService_client_handle_t client_handle,
3096		const char * endpoint,
3097		const xsd_QName * input,
3098		RegistryPortType_GetResourceProperty_request_callback_func_t callback,
3099		void * callback_arg)
3100	0	{
3101	0	return globus_soap_client_register_request(
3102		client_handle,
3103		endpoint,
3104		&RegistryPortType_l_GetResourceProperty_operation,
3105		(void *) input,
3106		callback,
3107		callback_arg);
3108		}
3109
3110
3111
3112		static
3113		void
3114		RegistryPortType_l_GetResourceProperty_deserialize_fault(
3115		globus_soap_message_handle_t handle,
3116		const xsd_QName * fault_qname,
3117		int * fault_type)
3118	0	{
3119	0	*fault_type = REGISTRYPORTTYPE_GETRESOURCEPROPERTY_NOFAULT;
3120
3121	0	if(fault_qname)
3122		{
3123	0	if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
3124		fault_qname == (&wsr_ResourceUnknownFault_qname))
3125		{
3126	0	*fault_type = REGISTRYPORTTYPE_GETRESOURCEPROPERTY_RESOURCEUNKNOWNFAULT;
3127		}
3128	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
3129		fault_qname == (&wsr_ResourceUnavailableFault_qname))
3130		{
3131	0	*fault_type = REGISTRYPORTTYPE_GETRESOURCEPROPERTY_RESOURCEUNAVAILABLEFAULT;
3132		}
3133	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
3134		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
3135		{
3136	0	*fault_type = REGISTRYPORTTYPE_GETRESOURCEPROPERTY_INVALIDRESOURCEPROPERTYQNAMEFAULT;
3137		}
3138		else
3139		{
3140	0	*fault_type = REGISTRYPORTTYPE_GETRESOURCEPROPERTY_UNKNOWN_FAULT;
3141		}
3142		}
3143	0	}
3144		/* RegistryPortType_l_GetResourceProperty_deserialize_fault() */
3145
3146		/**
3147		* Nonblocking operation response handling
3148		* @ingroup RegistryPortType_GetResourceProperty_operation
3149		* Begin parsing the request for the <code>GetResourceProperty</code> operation begun
3150		* by an earlier call to
3151		* RegistryPortType_GetResourceProperty_register_request() or
3152		* RegistryPortType_GetResourceProperty_epr_register_request(). Once the response has been parsed.
3153		* the @a callback function will be called to pass the result of the operation
3154		* to the application.
3155		*
3156		* @param client_handle
3157		* The @link #RegistryService_client_handle_t client handle @endlink which
3158		* contains the state related to processing this operation.
3159		* @param callback
3160		* Callback function which will be called once the response has been
3161		* processed.
3162		* @param callback_arg
3163		* Application-specific pointer which will be passed to the callback.
3164		*/
3165		globus_result_t
3166		RegistryPortType_GetResourceProperty_register_response(
3167		RegistryService_client_handle_t client_handle,
3168		RegistryPortType_GetResourceProperty_response_callback_func_t callback,
3169		void * callback_arg)
3170	0	{
3171	0	return globus_soap_client_register_response(
3172		client_handle,
3173		(globus_soap_client_response_callback_func_t) callback,
3174		callback_arg);
3175		}
3176
3177		/**
3178		* Nonblocking operation invocation with EPR
3179		* @ingroup RegistryPortType_GetResourceProperty_operation
3180		*
3181		* Begin processing a request for the GetResourceProperty operation. The operation will
3182		* sent to the service named by the @a epr and after the response is received,
3183		* the @a callback function will be invoked.
3184		*
3185		* @param handle
3186		* The @link #RegistryService_client_handle_t client handle @endlink which
3187		* contains the state related to processing this operation.
3188		* @param epr
3189		* Endpoint Reference of the service and resource which will process
3190		* the operation.
3191		* @param input
3192		* Input parameter to the operation.
3193		* @param callback
3194		* Callback function which will be called once the operation has been
3195		* processed.
3196		* @param callback_arg
3197		* Application-specific pointer which will be passed to the callback.
3198		*/
3199		globus_result_t
3200		RegistryPortType_GetResourceProperty_epr_register(
3201		RegistryService_client_handle_t handle,
3202		const wsa_EndpointReferenceType * epr,
3203		const xsd_QName * input,
3204		RegistryPortType_GetResourceProperty_response_callback_func_t callback,
3205		void * callback_arg)
3206	0	{
3207		globus_result_t result;
3208
3209	0	result = globus_soap_client_handle_attr_set(
3210		handle,
3211		WSADDR_EPR_KEY,
3212		wsa_EndpointReferenceType_info.copy,
3213		wsa_EndpointReferenceType_info.destroy,
3214		(void *) epr);
3215
3216	0	if (result != GLOBUS_SUCCESS)
3217		{
3218	0	goto out;
3219		}
3220
3221	0	result = globus_soap_client_operation_register(
3222		handle,
3223		epr->Address.base_value,
3224		&RegistryPortType_l_GetResourceProperty_operation,
3225		(void *) input,
3226		(globus_soap_client_response_callback_func_t) callback,
3227		callback_arg);
3228	0	out:
3229	0	return result;
3230		}
3231
3232		/**
3233		* Nonblocking operation invocation
3234		* @ingroup RegistryPortType_GetResourceProperty_operation
3235		*
3236		* Begin processing a request for the GetResourceProperty operation. The operation will
3237		* sent to the service located at @a endpoint and after the response is
3238		* received, the @a callback function will be invoked.
3239		*
3240		* @param handle
3241		* The @link #RegistryService_client_handle_t client handle @endlink which
3242		* contains the state related to processing this operation.
3243		* @param endpoint
3244		* URI of the service endpoint to send the request to.
3245		* @param input
3246		* Input parameter to the operation.
3247		* @param callback
3248		* Callback function which will be called once the operation has been
3249		* processed.
3250		* @param callback_arg
3251		* Application-specific pointer which will be passed to the callback.
3252		*/
3253		globus_result_t
3254		RegistryPortType_GetResourceProperty_register(
3255		RegistryService_client_handle_t handle,
3256		const char * endpoint,
3257		const xsd_QName * input,
3258		RegistryPortType_GetResourceProperty_response_callback_func_t callback,
3259		void * callback_arg)
3260	0	{
3261	0	return globus_soap_client_operation_register(
3262		handle,
3263		endpoint,
3264		&RegistryPortType_l_GetResourceProperty_operation,
3265		(void *) input,
3266		(globus_soap_client_response_callback_func_t) callback,
3267		callback_arg);
3268		}
3269
3270
3271
3272		/**
3273		* Blocking operation invocation with EPR
3274		* @ingroup RegistryPortType_GetResourceProperty_operation
3275		*
3276		* Request that an the GetResourceProperty operation be invoked by the service and
3277		* resource named by the @a epr parameter.
3278
3279		* If the result is <code>GLOBUS_SUCCESS</code>, then the
3280		* @a output parameter will be set to the result of the operation.
3281		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
3282		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
3283		* error occurred, and the result's error type should be checked.
3284
3285		*
3286		* @param handle
3287		* The @link #RegistryService_client_handle_t client handle @endlink which
3288		* contains the state related to processing this operation.
3289		* @param epr
3290		* Endpoint Reference of the service and resource which will process
3291		* the operation.
3292		* @param input
3293		* Input parameter to the operation.
3294
3295		* @param output
3296		* The output of the operation, if the operation succeeded.
3297		* @param fault_type
3298		* The type of fault sent as a result of the operation, if the operation
3299		* failed. If the operation succeeded, this will be NULL.
3300		* @param fault
3301		* The fault element which was received, if the operation failed.
3302		* If the operation succeeded, this will be NULL.
3303
3304		*/
3305		globus_result_t
3306		RegistryPortType_GetResourceProperty_epr(
3307		RegistryService_client_handle_t handle,
3308		const wsa_EndpointReferenceType * epr,
3309		const xsd_QName * input,
3310		wsrp_GetResourcePropertyResponseType * * output,
3311		RegistryPortType_GetResourceProperty_fault_t * fault_type,
3312		xsd_any * * fault)
3313	0	{
3314		globus_result_t result;
3315
3316	0	result = globus_soap_client_handle_attr_set(
3317		handle,
3318		WSADDR_EPR_KEY,
3319		wsa_EndpointReferenceType_info.copy,
3320		wsa_EndpointReferenceType_info.destroy,
3321		(void *) epr);
3322
3323	0	if (result != GLOBUS_SUCCESS)
3324		{
3325	0	goto out;
3326		}
3327	0	result = globus_soap_client_operation(
3328		handle,
3329		epr->Address.base_value,
3330		&RegistryPortType_l_GetResourceProperty_operation,
3331		(void *) input,
3332
3333		(void **) output,
3334		(int *) fault_type,
3335		fault
3336		);
3337	0	out:
3338	0	return result;
3339		}
3340
3341		/**
3342		* Blocking operation invocation
3343		* @ingroup RegistryPortType_GetResourceProperty_operation
3344		*
3345		* Request that an the GetResourceProperty operation be invoked by the service at
3346		* @a endpoint.
3347
3348		* If the result is <code>GLOBUS_SUCCESS</code>, then the
3349		* @a output parameter will be set to the result of the operation.
3350		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
3351		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
3352		* error occurred, and the result's error type should be checked.
3353
3354		*
3355		* @param handle
3356		* The @link #RegistryService_client_handle_t client handle @endlink which
3357		* contains the state related to processing this operation.
3358		* @param endpoint
3359		* URI of the service endpoint to send the request to.
3360		* @param input
3361		* Input parameter to the operation.
3362
3363		* @param output
3364		* The output of the operation, if the operation succeeded.
3365		* @param fault_type
3366		* The type of fault sent as a result of the operation, if the operation
3367		* failed. If the operation succeeded, this will be NULL.
3368		* @param fault
3369		* The fault element which was received, if the operation failed.
3370		* If the operation succeeded, this will be NULL.
3371
3372		*/
3373		globus_result_t
3374		RegistryPortType_GetResourceProperty(
3375		RegistryService_client_handle_t handle,
3376		const char * endpoint,
3377		const xsd_QName * input,
3378		wsrp_GetResourcePropertyResponseType * * output,
3379		RegistryPortType_GetResourceProperty_fault_t * fault_type,
3380		xsd_any * * fault)
3381	0	{
3382	0	return globus_soap_client_operation(
3383		handle,
3384		endpoint,
3385		&RegistryPortType_l_GetResourceProperty_operation,
3386		(void *) input,
3387
3388		(void *) output,
3389		(int *) fault_type,
3390		fault
3391		);