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 "RegistryEntryService_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 * RegistryEntryService_l_extensions = NULL;
33		static globus_mutex_t RegistryEntryService_l_extensions_mutex;
34
35		static
36		int
37		RegistryEntryService_l_client_module_activate();
38
39		static
40		int
41		RegistryEntryService_l_client_module_deactivate();
42
43		globus_module_descriptor_t
44		RegistryEntryService_i_module =
45		{
46		"RegistryEntryService",
47		RegistryEntryService_l_client_module_activate,
48		RegistryEntryService_l_client_module_deactivate
49		};
50
51
52		static
53		void
54		RegistryEntryPortType_l_GetMultipleResourceProperties_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 RegistryEntryPortType_l_GetMultipleResourceProperties_operation =
62		{
63		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetMultipleResourceProperties" } ,
64		&wsrp_GetMultipleResourcePropertiesType_info,
65
66		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetMultipleResourcePropertiesResponse" },
67		&wsrp_GetMultipleResourcePropertiesResponseType_info,
68
69		"http://docs.oasis-open.org/wsrf/rpw-2/GetMultipleResourceProperties/GetMultipleResourcePropertiesRequest",
70
71		"http://docs.oasis-open.org/wsrf/rpw-2/GetMultipleResourceProperties/GetMultipleResourcePropertiesResponse",
72
73
74		RegistryEntryPortType_l_GetMultipleResourceProperties_deserialize_fault
75
76		};
77
78
79		static
80		void
81		RegistryEntryPortType_l_QueryResourceProperties_deserialize_fault(
82		globus_soap_message_handle_t handle,
83		const xsd_QName * fault_qname,
84		int * fault_type);
85
86
87		static
88		globus_soap_client_operation_t RegistryEntryPortType_l_QueryResourceProperties_operation =
89		{
90		{ "http://docs.oasis-open.org/wsrf/rp-2", "QueryResourceProperties" } ,
91		&wsrp_QueryResourcePropertiesType_info,
92
93		{ "http://docs.oasis-open.org/wsrf/rp-2", "QueryResourcePropertiesResponse" },
94		&wsrp_QueryResourcePropertiesResponseType_info,
95
96		"http://docs.oasis-open.org/wsrf/rpw-2/QueryResourceProperties/QueryResourcePropertiesRequest",
97
98		"http://docs.oasis-open.org/wsrf/rpw-2/QueryResourceProperties/QueryResourcePropertiesResponse",
99
100
101		RegistryEntryPortType_l_QueryResourceProperties_deserialize_fault
102
103		};
104
105
106		static
107		void
108		RegistryEntryPortType_l_GetResourceProperty_deserialize_fault(
109		globus_soap_message_handle_t handle,
110		const xsd_QName * fault_qname,
111		int * fault_type);
112
113
114		static
115		globus_soap_client_operation_t RegistryEntryPortType_l_GetResourceProperty_operation =
116		{
117		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetResourceProperty" } ,
118		&xsd_QName_info,
119
120		{ "http://docs.oasis-open.org/wsrf/rp-2", "GetResourcePropertyResponse" },
121		&wsrp_GetResourcePropertyResponseType_info,
122
123		"http://docs.oasis-open.org/wsrf/rpw-2/GetResourceProperty/GetResourcePropertyRequest",
124
125		"http://docs.oasis-open.org/wsrf/rpw-2/GetResourceProperty/GetResourcePropertyResponse",
126
127
128		RegistryEntryPortType_l_GetResourceProperty_deserialize_fault
129
130		};
131
132
133		static
134		int
135		RegistryEntryService_l_client_module_activate()
136	0	{
137	0	int res = 0;
138	0	globus_result_t result = GLOBUS_SUCCESS;
139	0	res = globus_module_activate(GLOBUS_SOAP_MESSAGE_MODULE);
140	0	if(res != GLOBUS_SUCCESS)
141		{
142	0	return res;
143		}
144
145	0	result = RegistryEntryService_registry_add_types(GLOBUS_GLOBAL_TYPE_REGISTRY);
146	0	if(result != GLOBUS_SUCCESS)
147		{
148	0	result = GlobusSoapMessageErrorFailedClientInit(
149		result, "RegistryEntryService");
150		}
151
152
153	0	globus_mutex_init(&RegistryEntryService_l_extensions_mutex, NULL);
154
155	0	return res;
156		}
157
158		static
159		void
160		RegistryEntryService_l_extension_destroy(
161		void * sym)
162	0	{
163	0	char * symbol = (char *) sym;
164
165	0	globus_extension_deactivate(symbol);
166	0	globus_free(symbol);
167	0	}
168
169		static
170		int
171		RegistryEntryService_l_client_module_deactivate()
172	0	{
173	0	int res = 0;
174
175	0	globus_module_deactivate(GLOBUS_SOAP_MESSAGE_MODULE);
176
177	0	globus_mutex_lock(&RegistryEntryService_l_extensions_mutex);
178	0	globus_list_destroy_all(
179		RegistryEntryService_l_extensions,
180		RegistryEntryService_l_extension_destroy);
181	0	RegistryEntryService_l_extensions = NULL;
182	0	globus_mutex_unlock(&RegistryEntryService_l_extensions_mutex);
183	0	globus_mutex_destroy(&RegistryEntryService_l_extensions_mutex);
184
185	0	return res;
186		}
187
188		/**
189		* Initialize a client handle
190		* @ingroup RegistryEntryService_client_handle
191		* Initialize new client handle state for use with operation-related functions.
192		*
193		* @param handle
194		* Pointer to the handle to initialize.
195		* @param attrs
196		* Default attributes to use with this handle. This parameter may be NULL.
197		* Certain atttributes may cause different handlers to be pushed onto the
198		* default handler chain for this client.
199		* @param handlers
200		* Handle chain to use with this handle. This parameter may be NULL.
201		* Typically the default handler chain used by this function is sufficient.
202		*/
203		globus_result_t
204		RegistryEntryService_client_init(
205		RegistryEntryService_client_handle_t * handle,
206		globus_soap_message_attr_t attrs,
207		globus_handler_chain_t chain)
208	0	{
209	0	RegistryEntryService_client_handle_t client_handle = NULL;
210	0	globus_result_t result = GLOBUS_SUCCESS;
211	0	globus_handler_chain_t tmp_chain = NULL;
212		GlobusFuncName(RegistryEntryService_client_init);
213	0	GlobusSoapMessageDebugEnter();
214
215	0	if (chain == NULL)
216		{
217	0	globus_handler_chain_init(&tmp_chain);
218
219	0	if(attrs &&
220		((int)globus_soap_message_attr_get(
221		attrs,
222		GLOBUS_SOAP_MESSAGE_AUTHENTICATION_METHOD_KEY)) ==
223		GLOBUS_SOAP_MESSAGE_AUTH_SECURE_MESSAGE)
224		{
225	0	result = globus_extension_activate(
226		"globus_handler_ws_secure_message");
227	0	if(result != GLOBUS_SUCCESS)
228		{
229	0	result = GlobusSoapMessageErrorFailedClientInit(
230		result, "RegistryEntryPortType_GetResourceProperty");
231	0	goto error;
232		}
233
234	0	globus_mutex_lock(&RegistryEntryService_l_extensions_mutex);
235	0	globus_list_insert(
236		&RegistryEntryService_l_extensions,
237		strdup("globus_handler_ws_secure_message"));
238	0	globus_mutex_unlock(&RegistryEntryService_l_extensions_mutex);
239
240	0	result = globus_handler_chain_push(
241		tmp_chain,
242		GLOBUS_HANDLER_TYPE_ALL,
243		"globus_handler_ws_secure_message_client");
244	0	if(result != GLOBUS_SUCCESS)
245		{
246	0	result = GlobusSoapMessageErrorFailedClientInit(
247		result, "RegistryEntryPortType_GetResourceProperty");
248	0	goto error;
249		}
250		}
251
252	0	result = globus_extension_activate(GLOBUS_HANDLER_WS_ADDRESSING_LIB);
253	0	if(result != GLOBUS_SUCCESS)
254		{
255	0	result = GlobusSoapMessageErrorFailedClientInit(
256		result, "RegistryEntryPortType_GetResourceProperty");
257	0	goto error;
258		}
259
260	0	globus_mutex_lock(&RegistryEntryService_l_extensions_mutex);
261	0	globus_list_insert(
262		&RegistryEntryService_l_extensions,
263		strdup(GLOBUS_HANDLER_WS_ADDRESSING_LIB));
264	0	globus_mutex_unlock(&RegistryEntryService_l_extensions_mutex);
265
266	0	result = globus_handler_chain_push(
267		tmp_chain,
268		GLOBUS_HANDLER_TYPE_REQUEST_ALL,
269		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
270	0	if(result != GLOBUS_SUCCESS)
271		{
272	0	result = GlobusSoapMessageErrorFailedClientInit(
273		result, "RegistryEntryPortType_GetResourceProperty");
274	0	goto error;
275		}
276
277	0	result = globus_handler_chain_push(
278		tmp_chain,
279		GLOBUS_HANDLER_TYPE_RESPONSE_ALL,
280		GLOBUS_HANDLER_WS_ADDRESSING_CLIENT);
281	0	if(result != GLOBUS_SUCCESS)
282		{
283	0	result = GlobusSoapMessageErrorFailedClientInit(
284		result, "RegistryEntryPortType_GetResourceProperty");
285	0	goto error;
286		}
287
288	0	chain = tmp_chain;
289		}
290
291	0	result = globus_soap_client_handle_init(
292		handle,
293		attrs,
294		chain);
295
296	0	GlobusSoapMessageDebugExit();
297	0	return result;
298
299	0	error:
300	0	if (tmp_chain != NULL)
301		{
302	0	globus_handler_chain_destroy(tmp_chain);
303		}
304	0	if (client_handle != NULL)
305		{
306	0	globus_free(client_handle);
307		}
308	0	GlobusSoapMessageDebugExit();
309	0	return result;
310		}
311		/* RegistryEntryService_client_init() */
312
313		/**
314		* Destroy a client handle
315		* @ingroup RegistryEntryService_client_handle
316		*
317		* Destroys the state associated with this client handle.
318		*
319		* @param handle
320		* Handle to destroy.
321		*/
322		void
323		RegistryEntryService_client_destroy(
324		RegistryEntryService_client_handle_t handle)
325	0	{
326	0	globus_soap_client_handle_destroy(handle);
327	0	}
328
329		/**
330		* Cancel the current operation associated with this handle.
331		* @ingroup RegistryEntryService_client_handle
332		*
333		* @param handle
334		* Handle which has the operation to cancel.
335		*/
336		globus_result_t
337		RegistryEntryService_client_operation_cancel(
338		RegistryEntryService_client_handle_t handle)
339	0	{
340	0	globus_result_t result = GLOBUS_SUCCESS;
341		GlobusFuncName(RegistryEntryService_client_message_cancel);
342	0	GlobusSoapMessageDebugEnter();
343
344	0	result = globus_soap_client_operation_cancel(handle);
345
346	0	return result;
347		}
348
349		/**
350		* Get handle's handler chain
351		* @ingroup RegistryEntryService_client_handle
352		*
353		* The handler chain contains information about which handlers (typically
354		* SOAP header processors) will be invoked when a request is sent or a
355		* response is received. Applications which want to add custom handlers at
356		* run time may wish to push additional handlers onto this chain.
357		*
358		* @param handle
359		* The handle to query.
360		* @param handlers
361		* A pointer to a handler chain which will be set to the handle's
362		* chain.
363		*/
364		globus_result_t
365		RegistryEntryService_client_get_handler_chain(
366		RegistryEntryService_client_handle_t handle,
367		globus_handler_chain_t * handlers)
368	0	{
369	0	globus_result_t result = GLOBUS_SUCCESS;
370		GlobusFuncName(RegistryEntryService_client_get_handle_chain);
371	0	GlobusSoapMessageDebugEnter();
372
373	0	result = globus_soap_client_handle_get_handler_chain(handle, handlers);
374
375	0	GlobusSoapMessageDebugExit();
376	0	return result;
377		}
378
379		/**
380		* Set a SOAP attribute on a handle
381		* @ingroup RegistryEntryService_client_handle
382		*
383		* Set a SOAP attribute on a handle. This can be used to change how
384		* the SOAP engine will process operations sent via this handle.
385		*
386		* @param handle
387		* The handle to modify.
388		* @param prop_name
389		* The attribute name. This should be one of the
390		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
391		* @param copy
392		* A function to copy the value. This is required if @a value will go
393		* out of scope.
394		* @param destroy
395		* A function to destroy a copy of the value. Required if @a copy is set.
396		* @param value
397		* The new value of the attribute.
398		*/
399		globus_result_t
400		RegistryEntryService_client_attr_set(
401		RegistryEntryService_client_handle_t handle,
402		const char * prop_name,
403		globus_soap_message_attr_copy_func_t copy,
404		globus_soap_message_attr_destroy_func_t destroy,
405		void * value)
406	0	{
407	0	return globus_soap_client_handle_attr_set(
408		handle,
409		prop_name,
410		copy,
411		destroy,
412		value);
413		}
414
415		/**
416		* Remove a SOAP attribute from a handle
417		* @ingroup RegistryEntryService_client_handle
418		*
419		* Remove a SOAP attribute on a handle. This can be used to change how
420		* the SOAP engine will process operations sent via this handle.
421		*
422		* @param handle
423		* The handle to modify.
424		* @param prop_name
425		* The attribute name. This should be one of the
426		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
427		*
428		* @return
429		* This function returns the current value of the attribute.
430		*/
431		void *
432		RegistryEntryService_client_attr_remove(
433		RegistryEntryService_client_handle_t handle,
434		const char * prop_name)
435	0	{
436	0	return globus_soap_client_handle_attr_remove(
437		handle,
438		prop_name);
439		}
440
441		/**
442		* Get a SOAP attribute from a handle
443		* @ingroup RegistryEntryService_client_handle
444		*
445		* Get the current value of a SOAP attribute set on a handle.
446		*
447		* @param handle
448		* The handle to query.
449		* @param prop_name
450		* The attribute name. This should be one of the
451		* <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
452		*
453		* @return
454		* This function returns the current value of the attribute.
455		*/
456		void *
457		RegistryEntryService_client_attr_get(
458		RegistryEntryService_client_handle_t handle,
459		const char * prop_name)
460	0	{
461	0	return globus_soap_client_handle_attr_get(
462		handle,
463		prop_name);
464		}
465
466
467
468		/**
469		* Nonblocking operation request with EPR
470		* @ingroup RegistryEntryPortType_GetMultipleResourceProperties_operation
471		* Begin sending a request for the <code>GetMultipleResourceProperties</code> operation on a
472		* resource handled by the service named by the @a epr. When the operation
473		* request has been sent, the @a callback function will be invoked.
474		*
475		* @param client_handle
476		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
477		* contains the state related to processing this operation.
478		* @param epr
479		* Endpoint Reference of the service and resource which will process
480		* the operation.
481		* @param input
482		* Input parameter to the operation.
483		* @param callback
484		* Callback function which will be called once the request has been
485		* sent
486		* @param callback_arg
487		* Application-specific pointer which will be passed to the callback.
488		*/
489		globus_result_t
490		RegistryEntryPortType_GetMultipleResourceProperties_epr_register_request(
491		RegistryEntryService_client_handle_t client_handle,
492		const wsa_EndpointReferenceType * epr,
493		const wsrp_GetMultipleResourcePropertiesType * input,
494		RegistryEntryPortType_GetMultipleResourceProperties_request_callback_func_t callback,
495		void * callback_arg)
496	0	{
497	0	globus_result_t result = GLOBUS_SUCCESS;
498
499	0	globus_assert_string(epr, "NULL EndpointReference");
500	0	globus_assert_string(epr->Address.base_value,
501		"NULL EndpointReference Address");
502
503	0	result = globus_soap_client_handle_attr_set(
504		client_handle,
505		WSADDR_EPR_KEY,
506		wsa_EndpointReferenceType_info.copy,
507		wsa_EndpointReferenceType_info.destroy,
508		(void *) epr);
509
510	0	if (result != GLOBUS_SUCCESS)
511		{
512	0	goto out;
513		}
514
515	0	result = globus_soap_client_register_request(
516		client_handle,
517		epr->Address.base_value,
518		&RegistryEntryPortType_l_GetMultipleResourceProperties_operation,
519		(void *) input,
520		callback,
521		callback_arg);
522
523	0	out:
524	0	return result;
525		}
526
527		/**
528		* Nonblocking operation request
529		* @ingroup RegistryEntryPortType_GetMultipleResourceProperties_operation
530		* Begin sending a request for the <code>GetMultipleResourceProperties</code> operation to
531		* the service at @a endpoint. When the operation
532		* request has been sent, the @a callback function will be invoked.
533		* @param handle
534		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
535		* contains the state related to processing this operation.
536		* @param endpoint
537		* URI of the service endpoint to send the request to.
538		* @param input
539		* Input parameter to the operation.
540		* @param callback
541		* Callback function which will be called once the request has been
542		* sent
543		* @param callback_arg
544		* Application-specific pointer which will be passed to the callback.
545		*/
546		globus_result_t
547		RegistryEntryPortType_GetMultipleResourceProperties_register_request(
548		RegistryEntryService_client_handle_t client_handle,
549		const char * endpoint,
550		const wsrp_GetMultipleResourcePropertiesType * input,
551		RegistryEntryPortType_GetMultipleResourceProperties_request_callback_func_t callback,
552		void * callback_arg)
553	0	{
554	0	return globus_soap_client_register_request(
555		client_handle,
556		endpoint,
557		&RegistryEntryPortType_l_GetMultipleResourceProperties_operation,
558		(void *) input,
559		callback,
560		callback_arg);
561		}
562
563
564
565		static
566		void
567		RegistryEntryPortType_l_GetMultipleResourceProperties_deserialize_fault(
568		globus_soap_message_handle_t handle,
569		const xsd_QName * fault_qname,
570		int * fault_type)
571	0	{
572	0	*fault_type = REGISTRYENTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_NOFAULT;
573
574	0	if(fault_qname)
575		{
576	0	if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
577		fault_qname == (&wsr_ResourceUnknownFault_qname))
578		{
579	0	*fault_type = REGISTRYENTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_RESOURCEUNKNOWNFAULT;
580		}
581	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
582		fault_qname == (&wsr_ResourceUnavailableFault_qname))
583		{
584	0	*fault_type = REGISTRYENTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_RESOURCEUNAVAILABLEFAULT;
585		}
586	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
587		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
588		{
589	0	*fault_type = REGISTRYENTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_INVALIDRESOURCEPROPERTYQNAMEFAULT;
590		}
591		else
592		{
593	0	*fault_type = REGISTRYENTRYPORTTYPE_GETMULTIPLERESOURCEPROPERTIES_UNKNOWN_FAULT;
594		}
595		}
596	0	}
597		/* RegistryEntryPortType_l_GetMultipleResourceProperties_deserialize_fault() */
598
599		/**
600		* Nonblocking operation response handling
601		* @ingroup RegistryEntryPortType_GetMultipleResourceProperties_operation
602		* Begin parsing the request for the <code>GetMultipleResourceProperties</code> operation begun
603		* by an earlier call to
604		* RegistryEntryPortType_GetMultipleResourceProperties_register_request() or
605		* RegistryEntryPortType_GetMultipleResourceProperties_epr_register_request(). Once the response has been parsed.
606		* the @a callback function will be called to pass the result of the operation
607		* to the application.
608		*
609		* @param client_handle
610		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
611		* contains the state related to processing this operation.
612		* @param callback
613		* Callback function which will be called once the response has been
614		* processed.
615		* @param callback_arg
616		* Application-specific pointer which will be passed to the callback.
617		*/
618		globus_result_t
619		RegistryEntryPortType_GetMultipleResourceProperties_register_response(
620		RegistryEntryService_client_handle_t client_handle,
621		RegistryEntryPortType_GetMultipleResourceProperties_response_callback_func_t callback,
622		void * callback_arg)
623	0	{
624	0	return globus_soap_client_register_response(
625		client_handle,
626		(globus_soap_client_response_callback_func_t) callback,
627		callback_arg);
628		}
629
630		/**
631		* Nonblocking operation invocation with EPR
632		* @ingroup RegistryEntryPortType_GetMultipleResourceProperties_operation
633		*
634		* Begin processing a request for the GetMultipleResourceProperties operation. The operation will
635		* sent to the service named by the @a epr and after the response is received,
636		* the @a callback function will be invoked.
637		*
638		* @param handle
639		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
640		* contains the state related to processing this operation.
641		* @param epr
642		* Endpoint Reference of the service and resource which will process
643		* the operation.
644		* @param input
645		* Input parameter to the operation.
646		* @param callback
647		* Callback function which will be called once the operation has been
648		* processed.
649		* @param callback_arg
650		* Application-specific pointer which will be passed to the callback.
651		*/
652		globus_result_t
653		RegistryEntryPortType_GetMultipleResourceProperties_epr_register(
654		RegistryEntryService_client_handle_t handle,
655		const wsa_EndpointReferenceType * epr,
656		const wsrp_GetMultipleResourcePropertiesType * input,
657		RegistryEntryPortType_GetMultipleResourceProperties_response_callback_func_t callback,
658		void * callback_arg)
659	0	{
660		globus_result_t result;
661
662	0	result = globus_soap_client_handle_attr_set(
663		handle,
664		WSADDR_EPR_KEY,
665		wsa_EndpointReferenceType_info.copy,
666		wsa_EndpointReferenceType_info.destroy,
667		(void *) epr);
668
669	0	if (result != GLOBUS_SUCCESS)
670		{
671	0	goto out;
672		}
673
674	0	result = globus_soap_client_operation_register(
675		handle,
676		epr->Address.base_value,
677		&RegistryEntryPortType_l_GetMultipleResourceProperties_operation,
678		(void *) input,
679		(globus_soap_client_response_callback_func_t) callback,
680		callback_arg);
681	0	out:
682	0	return result;
683		}
684
685		/**
686		* Nonblocking operation invocation
687		* @ingroup RegistryEntryPortType_GetMultipleResourceProperties_operation
688		*
689		* Begin processing a request for the GetMultipleResourceProperties operation. The operation will
690		* sent to the service located at @a endpoint and after the response is
691		* received, the @a callback function will be invoked.
692		*
693		* @param handle
694		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
695		* contains the state related to processing this operation.
696		* @param endpoint
697		* URI of the service endpoint to send the request to.
698		* @param input
699		* Input parameter to the operation.
700		* @param callback
701		* Callback function which will be called once the operation has been
702		* processed.
703		* @param callback_arg
704		* Application-specific pointer which will be passed to the callback.
705		*/
706		globus_result_t
707		RegistryEntryPortType_GetMultipleResourceProperties_register(
708		RegistryEntryService_client_handle_t handle,
709		const char * endpoint,
710		const wsrp_GetMultipleResourcePropertiesType * input,
711		RegistryEntryPortType_GetMultipleResourceProperties_response_callback_func_t callback,
712		void * callback_arg)
713	0	{
714	0	return globus_soap_client_operation_register(
715		handle,
716		endpoint,
717		&RegistryEntryPortType_l_GetMultipleResourceProperties_operation,
718		(void *) input,
719		(globus_soap_client_response_callback_func_t) callback,
720		callback_arg);
721		}
722
723
724
725		/**
726		* Blocking operation invocation with EPR
727		* @ingroup RegistryEntryPortType_GetMultipleResourceProperties_operation
728		*
729		* Request that an the GetMultipleResourceProperties operation be invoked by the service and
730		* resource named by the @a epr parameter.
731
732		* If the result is <code>GLOBUS_SUCCESS</code>, then the
733		* @a output parameter will be set to the result of the operation.
734		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
735		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
736		* error occurred, and the result's error type should be checked.
737
738		*
739		* @param handle
740		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
741		* contains the state related to processing this operation.
742		* @param epr
743		* Endpoint Reference of the service and resource which will process
744		* the operation.
745		* @param input
746		* Input parameter to the operation.
747
748		* @param output
749		* The output of the operation, if the operation succeeded.
750		* @param fault_type
751		* The type of fault sent as a result of the operation, if the operation
752		* failed. If the operation succeeded, this will be NULL.
753		* @param fault
754		* The fault element which was received, if the operation failed.
755		* If the operation succeeded, this will be NULL.
756
757		*/
758		globus_result_t
759		RegistryEntryPortType_GetMultipleResourceProperties_epr(
760		RegistryEntryService_client_handle_t handle,
761		const wsa_EndpointReferenceType * epr,
762		const wsrp_GetMultipleResourcePropertiesType * input,
763		wsrp_GetMultipleResourcePropertiesResponseType * * output,
764		RegistryEntryPortType_GetMultipleResourceProperties_fault_t * fault_type,
765		xsd_any * * fault)
766	0	{
767		globus_result_t result;
768
769	0	result = globus_soap_client_handle_attr_set(
770		handle,
771		WSADDR_EPR_KEY,
772		wsa_EndpointReferenceType_info.copy,
773		wsa_EndpointReferenceType_info.destroy,
774		(void *) epr);
775
776	0	if (result != GLOBUS_SUCCESS)
777		{
778	0	goto out;
779		}
780	0	result = globus_soap_client_operation(
781		handle,
782		epr->Address.base_value,
783		&RegistryEntryPortType_l_GetMultipleResourceProperties_operation,
784		(void *) input,
785
786		(void **) output,
787		(int *) fault_type,
788		fault
789		);
790	0	out:
791	0	return result;
792		}
793
794		/**
795		* Blocking operation invocation
796		* @ingroup RegistryEntryPortType_GetMultipleResourceProperties_operation
797		*
798		* Request that an the GetMultipleResourceProperties operation be invoked by the service at
799		* @a endpoint.
800
801		* If the result is <code>GLOBUS_SUCCESS</code>, then the
802		* @a output parameter will be set to the result of the operation.
803		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
804		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
805		* error occurred, and the result's error type should be checked.
806
807		*
808		* @param handle
809		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
810		* contains the state related to processing this operation.
811		* @param endpoint
812		* URI of the service endpoint to send the request to.
813		* @param input
814		* Input parameter to the operation.
815
816		* @param output
817		* The output of the operation, if the operation succeeded.
818		* @param fault_type
819		* The type of fault sent as a result of the operation, if the operation
820		* failed. If the operation succeeded, this will be NULL.
821		* @param fault
822		* The fault element which was received, if the operation failed.
823		* If the operation succeeded, this will be NULL.
824
825		*/
826		globus_result_t
827		RegistryEntryPortType_GetMultipleResourceProperties(
828		RegistryEntryService_client_handle_t handle,
829		const char * endpoint,
830		const wsrp_GetMultipleResourcePropertiesType * input,
831		wsrp_GetMultipleResourcePropertiesResponseType * * output,
832		RegistryEntryPortType_GetMultipleResourceProperties_fault_t * fault_type,
833		xsd_any * * fault)
834	0	{
835	0	return globus_soap_client_operation(
836		handle,
837		endpoint,
838		&RegistryEntryPortType_l_GetMultipleResourceProperties_operation,
839		(void *) input,
840
841		(void *) output,
842		(int *) fault_type,
843		fault
844		);
845		}
846
847
848		/**
849		* Nonblocking operation request with EPR
850		* @ingroup RegistryEntryPortType_QueryResourceProperties_operation
851		* Begin sending a request for the <code>QueryResourceProperties</code> operation on a
852		* resource handled by the service named by the @a epr. When the operation
853		* request has been sent, the @a callback function will be invoked.
854		*
855		* @param client_handle
856		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
857		* contains the state related to processing this operation.
858		* @param epr
859		* Endpoint Reference of the service and resource which will process
860		* the operation.
861		* @param input
862		* Input parameter to the operation.
863		* @param callback
864		* Callback function which will be called once the request has been
865		* sent
866		* @param callback_arg
867		* Application-specific pointer which will be passed to the callback.
868		*/
869		globus_result_t
870		RegistryEntryPortType_QueryResourceProperties_epr_register_request(
871		RegistryEntryService_client_handle_t client_handle,
872		const wsa_EndpointReferenceType * epr,
873		const wsrp_QueryResourcePropertiesType * input,
874		RegistryEntryPortType_QueryResourceProperties_request_callback_func_t callback,
875		void * callback_arg)
876	0	{
877	0	globus_result_t result = GLOBUS_SUCCESS;
878
879	0	globus_assert_string(epr, "NULL EndpointReference");
880	0	globus_assert_string(epr->Address.base_value,
881		"NULL EndpointReference Address");
882
883	0	result = globus_soap_client_handle_attr_set(
884		client_handle,
885		WSADDR_EPR_KEY,
886		wsa_EndpointReferenceType_info.copy,
887		wsa_EndpointReferenceType_info.destroy,
888		(void *) epr);
889
890	0	if (result != GLOBUS_SUCCESS)
891		{
892	0	goto out;
893		}
894
895	0	result = globus_soap_client_register_request(
896		client_handle,
897		epr->Address.base_value,
898		&RegistryEntryPortType_l_QueryResourceProperties_operation,
899		(void *) input,
900		callback,
901		callback_arg);
902
903	0	out:
904	0	return result;
905		}
906
907		/**
908		* Nonblocking operation request
909		* @ingroup RegistryEntryPortType_QueryResourceProperties_operation
910		* Begin sending a request for the <code>QueryResourceProperties</code> operation to
911		* the service at @a endpoint. When the operation
912		* request has been sent, the @a callback function will be invoked.
913		* @param handle
914		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
915		* contains the state related to processing this operation.
916		* @param endpoint
917		* URI of the service endpoint to send the request to.
918		* @param input
919		* Input parameter to the operation.
920		* @param callback
921		* Callback function which will be called once the request has been
922		* sent
923		* @param callback_arg
924		* Application-specific pointer which will be passed to the callback.
925		*/
926		globus_result_t
927		RegistryEntryPortType_QueryResourceProperties_register_request(
928		RegistryEntryService_client_handle_t client_handle,
929		const char * endpoint,
930		const wsrp_QueryResourcePropertiesType * input,
931		RegistryEntryPortType_QueryResourceProperties_request_callback_func_t callback,
932		void * callback_arg)
933	0	{
934	0	return globus_soap_client_register_request(
935		client_handle,
936		endpoint,
937		&RegistryEntryPortType_l_QueryResourceProperties_operation,
938		(void *) input,
939		callback,
940		callback_arg);
941		}
942
943
944
945		static
946		void
947		RegistryEntryPortType_l_QueryResourceProperties_deserialize_fault(
948		globus_soap_message_handle_t handle,
949		const xsd_QName * fault_qname,
950		int * fault_type)
951	0	{
952	0	*fault_type = REGISTRYENTRYPORTTYPE_QUERYRESOURCEPROPERTIES_NOFAULT;
953
954	0	if(fault_qname)
955		{
956	0	if(fault_qname == (&wsrp_UnknownQueryExpressionDialectFaultType_qname) ||
957		fault_qname == (&wsrp_UnknownQueryExpressionDialectFault_qname))
958		{
959	0	*fault_type = REGISTRYENTRYPORTTYPE_QUERYRESOURCEPROPERTIES_UNKNOWNQUERYEXPRESSIONDIALECTFAULT;
960		}
961	0	else if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
962		fault_qname == (&wsr_ResourceUnknownFault_qname))
963		{
964	0	*fault_type = REGISTRYENTRYPORTTYPE_QUERYRESOURCEPROPERTIES_RESOURCEUNKNOWNFAULT;
965		}
966	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
967		fault_qname == (&wsr_ResourceUnavailableFault_qname))
968		{
969	0	*fault_type = REGISTRYENTRYPORTTYPE_QUERYRESOURCEPROPERTIES_RESOURCEUNAVAILABLEFAULT;
970		}
971	0	else if(fault_qname == (&wsrp_QueryEvaluationErrorFaultType_qname) ||
972		fault_qname == (&wsrp_QueryEvaluationErrorFault_qname))
973		{
974	0	*fault_type = REGISTRYENTRYPORTTYPE_QUERYRESOURCEPROPERTIES_QUERYEVALUATIONERRORFAULT;
975		}
976	0	else if(fault_qname == (&wsrp_InvalidQueryExpressionFaultType_qname) ||
977		fault_qname == (&wsrp_InvalidQueryExpressionFault_qname))
978		{
979	0	*fault_type = REGISTRYENTRYPORTTYPE_QUERYRESOURCEPROPERTIES_INVALIDQUERYEXPRESSIONFAULT;
980		}
981	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
982		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
983		{
984	0	*fault_type = REGISTRYENTRYPORTTYPE_QUERYRESOURCEPROPERTIES_INVALIDRESOURCEPROPERTYQNAMEFAULT;
985		}
986		else
987		{
988	0	*fault_type = REGISTRYENTRYPORTTYPE_QUERYRESOURCEPROPERTIES_UNKNOWN_FAULT;
989		}
990		}
991	0	}
992		/* RegistryEntryPortType_l_QueryResourceProperties_deserialize_fault() */
993
994		/**
995		* Nonblocking operation response handling
996		* @ingroup RegistryEntryPortType_QueryResourceProperties_operation
997		* Begin parsing the request for the <code>QueryResourceProperties</code> operation begun
998		* by an earlier call to
999		* RegistryEntryPortType_QueryResourceProperties_register_request() or
1000		* RegistryEntryPortType_QueryResourceProperties_epr_register_request(). Once the response has been parsed.
1001		* the @a callback function will be called to pass the result of the operation
1002		* to the application.
1003		*
1004		* @param client_handle
1005		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1006		* contains the state related to processing this operation.
1007		* @param callback
1008		* Callback function which will be called once the response has been
1009		* processed.
1010		* @param callback_arg
1011		* Application-specific pointer which will be passed to the callback.
1012		*/
1013		globus_result_t
1014		RegistryEntryPortType_QueryResourceProperties_register_response(
1015		RegistryEntryService_client_handle_t client_handle,
1016		RegistryEntryPortType_QueryResourceProperties_response_callback_func_t callback,
1017		void * callback_arg)
1018	0	{
1019	0	return globus_soap_client_register_response(
1020		client_handle,
1021		(globus_soap_client_response_callback_func_t) callback,
1022		callback_arg);
1023		}
1024
1025		/**
1026		* Nonblocking operation invocation with EPR
1027		* @ingroup RegistryEntryPortType_QueryResourceProperties_operation
1028		*
1029		* Begin processing a request for the QueryResourceProperties operation. The operation will
1030		* sent to the service named by the @a epr and after the response is received,
1031		* the @a callback function will be invoked.
1032		*
1033		* @param handle
1034		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1035		* contains the state related to processing this operation.
1036		* @param epr
1037		* Endpoint Reference of the service and resource which will process
1038		* the operation.
1039		* @param input
1040		* Input parameter to the operation.
1041		* @param callback
1042		* Callback function which will be called once the operation has been
1043		* processed.
1044		* @param callback_arg
1045		* Application-specific pointer which will be passed to the callback.
1046		*/
1047		globus_result_t
1048		RegistryEntryPortType_QueryResourceProperties_epr_register(
1049		RegistryEntryService_client_handle_t handle,
1050		const wsa_EndpointReferenceType * epr,
1051		const wsrp_QueryResourcePropertiesType * input,
1052		RegistryEntryPortType_QueryResourceProperties_response_callback_func_t callback,
1053		void * callback_arg)
1054	0	{
1055		globus_result_t result;
1056
1057	0	result = globus_soap_client_handle_attr_set(
1058		handle,
1059		WSADDR_EPR_KEY,
1060		wsa_EndpointReferenceType_info.copy,
1061		wsa_EndpointReferenceType_info.destroy,
1062		(void *) epr);
1063
1064	0	if (result != GLOBUS_SUCCESS)
1065		{
1066	0	goto out;
1067		}
1068
1069	0	result = globus_soap_client_operation_register(
1070		handle,
1071		epr->Address.base_value,
1072		&RegistryEntryPortType_l_QueryResourceProperties_operation,
1073		(void *) input,
1074		(globus_soap_client_response_callback_func_t) callback,
1075		callback_arg);
1076	0	out:
1077	0	return result;
1078		}
1079
1080		/**
1081		* Nonblocking operation invocation
1082		* @ingroup RegistryEntryPortType_QueryResourceProperties_operation
1083		*
1084		* Begin processing a request for the QueryResourceProperties operation. The operation will
1085		* sent to the service located at @a endpoint and after the response is
1086		* received, the @a callback function will be invoked.
1087		*
1088		* @param handle
1089		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1090		* contains the state related to processing this operation.
1091		* @param endpoint
1092		* URI of the service endpoint to send the request to.
1093		* @param input
1094		* Input parameter to the operation.
1095		* @param callback
1096		* Callback function which will be called once the operation has been
1097		* processed.
1098		* @param callback_arg
1099		* Application-specific pointer which will be passed to the callback.
1100		*/
1101		globus_result_t
1102		RegistryEntryPortType_QueryResourceProperties_register(
1103		RegistryEntryService_client_handle_t handle,
1104		const char * endpoint,
1105		const wsrp_QueryResourcePropertiesType * input,
1106		RegistryEntryPortType_QueryResourceProperties_response_callback_func_t callback,
1107		void * callback_arg)
1108	0	{
1109	0	return globus_soap_client_operation_register(
1110		handle,
1111		endpoint,
1112		&RegistryEntryPortType_l_QueryResourceProperties_operation,
1113		(void *) input,
1114		(globus_soap_client_response_callback_func_t) callback,
1115		callback_arg);
1116		}
1117
1118
1119
1120		/**
1121		* Blocking operation invocation with EPR
1122		* @ingroup RegistryEntryPortType_QueryResourceProperties_operation
1123		*
1124		* Request that an the QueryResourceProperties operation be invoked by the service and
1125		* resource named by the @a epr parameter.
1126
1127		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1128		* @a output parameter will be set to the result of the operation.
1129		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1130		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1131		* error occurred, and the result's error type should be checked.
1132
1133		*
1134		* @param handle
1135		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1136		* contains the state related to processing this operation.
1137		* @param epr
1138		* Endpoint Reference of the service and resource which will process
1139		* the operation.
1140		* @param input
1141		* Input parameter to the operation.
1142
1143		* @param output
1144		* The output of the operation, if the operation succeeded.
1145		* @param fault_type
1146		* The type of fault sent as a result of the operation, if the operation
1147		* failed. If the operation succeeded, this will be NULL.
1148		* @param fault
1149		* The fault element which was received, if the operation failed.
1150		* If the operation succeeded, this will be NULL.
1151
1152		*/
1153		globus_result_t
1154		RegistryEntryPortType_QueryResourceProperties_epr(
1155		RegistryEntryService_client_handle_t handle,
1156		const wsa_EndpointReferenceType * epr,
1157		const wsrp_QueryResourcePropertiesType * input,
1158		wsrp_QueryResourcePropertiesResponseType * * output,
1159		RegistryEntryPortType_QueryResourceProperties_fault_t * fault_type,
1160		xsd_any * * fault)
1161	0	{
1162		globus_result_t result;
1163
1164	0	result = globus_soap_client_handle_attr_set(
1165		handle,
1166		WSADDR_EPR_KEY,
1167		wsa_EndpointReferenceType_info.copy,
1168		wsa_EndpointReferenceType_info.destroy,
1169		(void *) epr);
1170
1171	0	if (result != GLOBUS_SUCCESS)
1172		{
1173	0	goto out;
1174		}
1175	0	result = globus_soap_client_operation(
1176		handle,
1177		epr->Address.base_value,
1178		&RegistryEntryPortType_l_QueryResourceProperties_operation,
1179		(void *) input,
1180
1181		(void **) output,
1182		(int *) fault_type,
1183		fault
1184		);
1185	0	out:
1186	0	return result;
1187		}
1188
1189		/**
1190		* Blocking operation invocation
1191		* @ingroup RegistryEntryPortType_QueryResourceProperties_operation
1192		*
1193		* Request that an the QueryResourceProperties operation be invoked by the service at
1194		* @a endpoint.
1195
1196		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1197		* @a output parameter will be set to the result of the operation.
1198		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1199		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1200		* error occurred, and the result's error type should be checked.
1201
1202		*
1203		* @param handle
1204		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1205		* contains the state related to processing this operation.
1206		* @param endpoint
1207		* URI of the service endpoint to send the request to.
1208		* @param input
1209		* Input parameter to the operation.
1210
1211		* @param output
1212		* The output of the operation, if the operation succeeded.
1213		* @param fault_type
1214		* The type of fault sent as a result of the operation, if the operation
1215		* failed. If the operation succeeded, this will be NULL.
1216		* @param fault
1217		* The fault element which was received, if the operation failed.
1218		* If the operation succeeded, this will be NULL.
1219
1220		*/
1221		globus_result_t
1222		RegistryEntryPortType_QueryResourceProperties(
1223		RegistryEntryService_client_handle_t handle,
1224		const char * endpoint,
1225		const wsrp_QueryResourcePropertiesType * input,
1226		wsrp_QueryResourcePropertiesResponseType * * output,
1227		RegistryEntryPortType_QueryResourceProperties_fault_t * fault_type,
1228		xsd_any * * fault)
1229	0	{
1230	0	return globus_soap_client_operation(
1231		handle,
1232		endpoint,
1233		&RegistryEntryPortType_l_QueryResourceProperties_operation,
1234		(void *) input,
1235
1236		(void *) output,
1237		(int *) fault_type,
1238		fault
1239		);
1240		}
1241
1242
1243		/**
1244		* Nonblocking operation request with EPR
1245		* @ingroup RegistryEntryPortType_GetResourceProperty_operation
1246		* Begin sending a request for the <code>GetResourceProperty</code> operation on a
1247		* resource handled by the service named by the @a epr. When the operation
1248		* request has been sent, the @a callback function will be invoked.
1249		*
1250		* @param client_handle
1251		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1252		* contains the state related to processing this operation.
1253		* @param epr
1254		* Endpoint Reference of the service and resource which will process
1255		* the operation.
1256		* @param input
1257		* Input parameter to the operation.
1258		* @param callback
1259		* Callback function which will be called once the request has been
1260		* sent
1261		* @param callback_arg
1262		* Application-specific pointer which will be passed to the callback.
1263		*/
1264		globus_result_t
1265		RegistryEntryPortType_GetResourceProperty_epr_register_request(
1266		RegistryEntryService_client_handle_t client_handle,
1267		const wsa_EndpointReferenceType * epr,
1268		const xsd_QName * input,
1269		RegistryEntryPortType_GetResourceProperty_request_callback_func_t callback,
1270		void * callback_arg)
1271	0	{
1272	0	globus_result_t result = GLOBUS_SUCCESS;
1273
1274	0	globus_assert_string(epr, "NULL EndpointReference");
1275	0	globus_assert_string(epr->Address.base_value,
1276		"NULL EndpointReference Address");
1277
1278	0	result = globus_soap_client_handle_attr_set(
1279		client_handle,
1280		WSADDR_EPR_KEY,
1281		wsa_EndpointReferenceType_info.copy,
1282		wsa_EndpointReferenceType_info.destroy,
1283		(void *) epr);
1284
1285	0	if (result != GLOBUS_SUCCESS)
1286		{
1287	0	goto out;
1288		}
1289
1290	0	result = globus_soap_client_register_request(
1291		client_handle,
1292		epr->Address.base_value,
1293		&RegistryEntryPortType_l_GetResourceProperty_operation,
1294		(void *) input,
1295		callback,
1296		callback_arg);
1297
1298	0	out:
1299	0	return result;
1300		}
1301
1302		/**
1303		* Nonblocking operation request
1304		* @ingroup RegistryEntryPortType_GetResourceProperty_operation
1305		* Begin sending a request for the <code>GetResourceProperty</code> operation to
1306		* the service at @a endpoint. When the operation
1307		* request has been sent, the @a callback function will be invoked.
1308		* @param handle
1309		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1310		* contains the state related to processing this operation.
1311		* @param endpoint
1312		* URI of the service endpoint to send the request to.
1313		* @param input
1314		* Input parameter to the operation.
1315		* @param callback
1316		* Callback function which will be called once the request has been
1317		* sent
1318		* @param callback_arg
1319		* Application-specific pointer which will be passed to the callback.
1320		*/
1321		globus_result_t
1322		RegistryEntryPortType_GetResourceProperty_register_request(
1323		RegistryEntryService_client_handle_t client_handle,
1324		const char * endpoint,
1325		const xsd_QName * input,
1326		RegistryEntryPortType_GetResourceProperty_request_callback_func_t callback,
1327		void * callback_arg)
1328	0	{
1329	0	return globus_soap_client_register_request(
1330		client_handle,
1331		endpoint,
1332		&RegistryEntryPortType_l_GetResourceProperty_operation,
1333		(void *) input,
1334		callback,
1335		callback_arg);
1336		}
1337
1338
1339
1340		static
1341		void
1342		RegistryEntryPortType_l_GetResourceProperty_deserialize_fault(
1343		globus_soap_message_handle_t handle,
1344		const xsd_QName * fault_qname,
1345		int * fault_type)
1346	0	{
1347	0	*fault_type = REGISTRYENTRYPORTTYPE_GETRESOURCEPROPERTY_NOFAULT;
1348
1349	0	if(fault_qname)
1350		{
1351	0	if(fault_qname == (&wsr_ResourceUnknownFaultType_qname) ||
1352		fault_qname == (&wsr_ResourceUnknownFault_qname))
1353		{
1354	0	*fault_type = REGISTRYENTRYPORTTYPE_GETRESOURCEPROPERTY_RESOURCEUNKNOWNFAULT;
1355		}
1356	0	else if(fault_qname == (&wsr_ResourceUnavailableFaultType_qname) ||
1357		fault_qname == (&wsr_ResourceUnavailableFault_qname))
1358		{
1359	0	*fault_type = REGISTRYENTRYPORTTYPE_GETRESOURCEPROPERTY_RESOURCEUNAVAILABLEFAULT;
1360		}
1361	0	else if(fault_qname == (&wsrp_InvalidResourcePropertyQNameFaultType_qname) ||
1362		fault_qname == (&wsrp_InvalidResourcePropertyQNameFault_qname))
1363		{
1364	0	*fault_type = REGISTRYENTRYPORTTYPE_GETRESOURCEPROPERTY_INVALIDRESOURCEPROPERTYQNAMEFAULT;
1365		}
1366		else
1367		{
1368	0	*fault_type = REGISTRYENTRYPORTTYPE_GETRESOURCEPROPERTY_UNKNOWN_FAULT;
1369		}
1370		}
1371	0	}
1372		/* RegistryEntryPortType_l_GetResourceProperty_deserialize_fault() */
1373
1374		/**
1375		* Nonblocking operation response handling
1376		* @ingroup RegistryEntryPortType_GetResourceProperty_operation
1377		* Begin parsing the request for the <code>GetResourceProperty</code> operation begun
1378		* by an earlier call to
1379		* RegistryEntryPortType_GetResourceProperty_register_request() or
1380		* RegistryEntryPortType_GetResourceProperty_epr_register_request(). Once the response has been parsed.
1381		* the @a callback function will be called to pass the result of the operation
1382		* to the application.
1383		*
1384		* @param client_handle
1385		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1386		* contains the state related to processing this operation.
1387		* @param callback
1388		* Callback function which will be called once the response has been
1389		* processed.
1390		* @param callback_arg
1391		* Application-specific pointer which will be passed to the callback.
1392		*/
1393		globus_result_t
1394		RegistryEntryPortType_GetResourceProperty_register_response(
1395		RegistryEntryService_client_handle_t client_handle,
1396		RegistryEntryPortType_GetResourceProperty_response_callback_func_t callback,
1397		void * callback_arg)
1398	0	{
1399	0	return globus_soap_client_register_response(
1400		client_handle,
1401		(globus_soap_client_response_callback_func_t) callback,
1402		callback_arg);
1403		}
1404
1405		/**
1406		* Nonblocking operation invocation with EPR
1407		* @ingroup RegistryEntryPortType_GetResourceProperty_operation
1408		*
1409		* Begin processing a request for the GetResourceProperty operation. The operation will
1410		* sent to the service named by the @a epr and after the response is received,
1411		* the @a callback function will be invoked.
1412		*
1413		* @param handle
1414		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1415		* contains the state related to processing this operation.
1416		* @param epr
1417		* Endpoint Reference of the service and resource which will process
1418		* the operation.
1419		* @param input
1420		* Input parameter to the operation.
1421		* @param callback
1422		* Callback function which will be called once the operation has been
1423		* processed.
1424		* @param callback_arg
1425		* Application-specific pointer which will be passed to the callback.
1426		*/
1427		globus_result_t
1428		RegistryEntryPortType_GetResourceProperty_epr_register(
1429		RegistryEntryService_client_handle_t handle,
1430		const wsa_EndpointReferenceType * epr,
1431		const xsd_QName * input,
1432		RegistryEntryPortType_GetResourceProperty_response_callback_func_t callback,
1433		void * callback_arg)
1434	0	{
1435		globus_result_t result;
1436
1437	0	result = globus_soap_client_handle_attr_set(
1438		handle,
1439		WSADDR_EPR_KEY,
1440		wsa_EndpointReferenceType_info.copy,
1441		wsa_EndpointReferenceType_info.destroy,
1442		(void *) epr);
1443
1444	0	if (result != GLOBUS_SUCCESS)
1445		{
1446	0	goto out;
1447		}
1448
1449	0	result = globus_soap_client_operation_register(
1450		handle,
1451		epr->Address.base_value,
1452		&RegistryEntryPortType_l_GetResourceProperty_operation,
1453		(void *) input,
1454		(globus_soap_client_response_callback_func_t) callback,
1455		callback_arg);
1456	0	out:
1457	0	return result;
1458		}
1459
1460		/**
1461		* Nonblocking operation invocation
1462		* @ingroup RegistryEntryPortType_GetResourceProperty_operation
1463		*
1464		* Begin processing a request for the GetResourceProperty operation. The operation will
1465		* sent to the service located at @a endpoint and after the response is
1466		* received, the @a callback function will be invoked.
1467		*
1468		* @param handle
1469		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1470		* contains the state related to processing this operation.
1471		* @param endpoint
1472		* URI of the service endpoint to send the request to.
1473		* @param input
1474		* Input parameter to the operation.
1475		* @param callback
1476		* Callback function which will be called once the operation has been
1477		* processed.
1478		* @param callback_arg
1479		* Application-specific pointer which will be passed to the callback.
1480		*/
1481		globus_result_t
1482		RegistryEntryPortType_GetResourceProperty_register(
1483		RegistryEntryService_client_handle_t handle,
1484		const char * endpoint,
1485		const xsd_QName * input,
1486		RegistryEntryPortType_GetResourceProperty_response_callback_func_t callback,
1487		void * callback_arg)
1488	0	{
1489	0	return globus_soap_client_operation_register(
1490		handle,
1491		endpoint,
1492		&RegistryEntryPortType_l_GetResourceProperty_operation,
1493		(void *) input,
1494		(globus_soap_client_response_callback_func_t) callback,
1495		callback_arg);
1496		}
1497
1498
1499
1500		/**
1501		* Blocking operation invocation with EPR
1502		* @ingroup RegistryEntryPortType_GetResourceProperty_operation
1503		*
1504		* Request that an the GetResourceProperty operation be invoked by the service and
1505		* resource named by the @a epr parameter.
1506
1507		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1508		* @a output parameter will be set to the result of the operation.
1509		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1510		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1511		* error occurred, and the result's error type should be checked.
1512
1513		*
1514		* @param handle
1515		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1516		* contains the state related to processing this operation.
1517		* @param epr
1518		* Endpoint Reference of the service and resource which will process
1519		* the operation.
1520		* @param input
1521		* Input parameter to the operation.
1522
1523		* @param output
1524		* The output of the operation, if the operation succeeded.
1525		* @param fault_type
1526		* The type of fault sent as a result of the operation, if the operation
1527		* failed. If the operation succeeded, this will be NULL.
1528		* @param fault
1529		* The fault element which was received, if the operation failed.
1530		* If the operation succeeded, this will be NULL.
1531
1532		*/
1533		globus_result_t
1534		RegistryEntryPortType_GetResourceProperty_epr(
1535		RegistryEntryService_client_handle_t handle,
1536		const wsa_EndpointReferenceType * epr,
1537		const xsd_QName * input,
1538		wsrp_GetResourcePropertyResponseType * * output,
1539		RegistryEntryPortType_GetResourceProperty_fault_t * fault_type,
1540		xsd_any * * fault)
1541	0	{
1542		globus_result_t result;
1543
1544	0	result = globus_soap_client_handle_attr_set(
1545		handle,
1546		WSADDR_EPR_KEY,
1547		wsa_EndpointReferenceType_info.copy,
1548		wsa_EndpointReferenceType_info.destroy,
1549		(void *) epr);
1550
1551	0	if (result != GLOBUS_SUCCESS)
1552		{
1553	0	goto out;
1554		}
1555	0	result = globus_soap_client_operation(
1556		handle,
1557		epr->Address.base_value,
1558		&RegistryEntryPortType_l_GetResourceProperty_operation,
1559		(void *) input,
1560
1561		(void **) output,
1562		(int *) fault_type,
1563		fault
1564		);
1565	0	out:
1566	0	return result;
1567		}
1568
1569		/**
1570		* Blocking operation invocation
1571		* @ingroup RegistryEntryPortType_GetResourceProperty_operation
1572		*
1573		* Request that an the GetResourceProperty operation be invoked by the service at
1574		* @a endpoint.
1575
1576		* If the result is <code>GLOBUS_SUCCESS</code>, then the
1577		* @a output parameter will be set to the result of the operation.
1578		* Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
1579		* they indicate the SOAP fault type. If they are NULL, then some non-SOAP
1580		* error occurred, and the result's error type should be checked.
1581
1582		*
1583		* @param handle
1584		* The @link #RegistryEntryService_client_handle_t client handle @endlink which
1585		* contains the state related to processing this operation.
1586		* @param endpoint
1587		* URI of the service endpoint to send the request to.
1588		* @param input
1589		* Input parameter to the operation.
1590
1591		* @param output
1592		* The output of the operation, if the operation succeeded.
1593		* @param fault_type
1594		* The type of fault sent as a result of the operation, if the operation
1595		* failed. If the operation succeeded, this will be NULL.
1596		* @param fault
1597		* The fault element which was received, if the operation failed.
1598		* If the operation succeeded, this will be NULL.
1599
1600		*/
1601		globus_result_t
1602		RegistryEntryPortType_GetResourceProperty(
1603		RegistryEntryService_client_handle_t handle,
1604		const char * endpoint,
1605		const xsd_QName * input,
1606		wsrp_GetResourcePropertyResponseType * * output,
1607		RegistryEntryPortType_GetResourceProperty_fault_t * fault_type,
1608		xsd_any * * fault)
1609	0	{
1610	0	return globus_soap_client_operation(
1611		handle,
1612		endpoint,
1613		&RegistryEntryPortType_l_GetResourceProperty_operation,
1614		(void *) input,
1615
1616		(void *) output,
1617		(int *) fault_type,
1618		fault
1619		);