|
||
|
Namespace of the wst_StatusCodeOpenEnum complex type.
Definition at line 68 of file wst_StatusCodeOpenEnum.h. |
|
||
|
Local part of the QName of the wst_StatusCodeOpenEnum complex type.
Definition at line 73 of file wst_StatusCodeOpenEnum.h. |
|
||
|
Optional wst_StatusCodeOpenEnum element.
Definition at line 43 of file wst_StatusCodeOpenEnum.h. |
|
||
|
|||||||
|
Initialize a wst_StatusCodeOpenEnum. Allocates a new wst_StatusCodeOpenEnum and initializes its contents. When the structure is no longer needed, it should be freed by calling wst_StatusCodeOpenEnum_destroy().
Definition at line 303 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum, and wst_StatusCodeOpenEnum_init(). Referenced by wst_StatusCodeOpenEnum_deserialize_contents_wrapper(), wst_StatusCodeOpenEnum_deserialize_pointer(), wst_StatusCodeOpenEnum_init(), and wst_StatusCodeOpenEnum_init_wrapper().
00305 {
00306 wst_StatusCodeOpenEnum * instance;
00307 globus_result_t result = GLOBUS_SUCCESS;
00308 GlobusFuncName(wst_StatusCodeOpenEnum_init);
00309 GlobusSoapMessageDebugEnter();
00310
00311
00312
00313 instance = (wst_StatusCodeOpenEnum *)
00314 globus_malloc(sizeof(wst_StatusCodeOpenEnum));
00315 if(!instance)
00316 {
00317 result = GlobusSoapMessageErrorOutOfMemory;
00318 GlobusSoapMessageDebugExit();
00319 return result;
00320 }
00321
00322 memset(instance, 0, sizeof(wst_StatusCodeOpenEnum));
00323
00324 *object = instance;
00325
00326 GlobusSoapMessageDebugExit();
00327 return result;
00328 }
|
|
|||||||
|
Destroy a wst_StatusCodeOpenEnum. Frees a wst_StatusCodeOpenEnum. All subelements and attributes will be destroyed (and freed if they are optional).
Definition at line 331 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_destroy(), and wst_StatusCodeOpenEnum_destroy_contents(). Referenced by wst_StatusCodeOpenEnum_destroy(), and wst_StatusCodeOpenEnum_destroy_wrapper().
00333 {
00334 GlobusFuncName(wst_StatusCodeOpenEnum_destroy);
00335 GlobusSoapMessageDebugEnter();
00336
00337 if(!instance)
00338 {
00339 goto exit;
00340 }
00341
00342 wst_StatusCodeOpenEnum_destroy_contents(instance);
00343 globus_free(instance);
00344
00345 exit:
00346
00347 GlobusSoapMessageDebugExit();
00348 }
|
|
|||||||||
|
Copy a wst_StatusCodeOpenEnum. Perform a deep copy of a wst_StatusCodeOpenEnum. The dest structure will be allocated, and then a copy of the contents of src and its subelements and attributes will be made to dest.
Definition at line 369 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum, wst_StatusCodeOpenEnum_copy(), and wst_StatusCodeOpenEnum_copy_contents(). Referenced by wst_StatusCodeOpenEnum_copy(), and wst_StatusCodeOpenEnum_copy_wrapper().
00372 {
00373 globus_result_t result = GLOBUS_SUCCESS;
00374 wst_StatusCodeOpenEnum * instance;
00375 GlobusFuncName(wst_StatusCodeOpenEnum_copy);
00376
00377 GlobusSoapMessageDebugEnter();
00378
00379 instance = malloc(sizeof(wst_StatusCodeOpenEnum));
00380 if (instance == NULL)
00381 {
00382 GlobusSoapMessageDebugExit();
00383 return GlobusSoapMessageErrorOutOfMemory;
00384 }
00385
00386 result = wst_StatusCodeOpenEnum_copy_contents(instance, src_obj);
00387 if(result != GLOBUS_SUCCESS)
00388 {
00389 globus_free(instance);
00390 GlobusSoapMessageDebugExit();
00391 return GlobusSoapMessageErrorOutOfMemory;
00392 }
00393
00394 *dest_obj = instance;
00395 GlobusSoapMessageDebugExit();
00396 return result;
00397 }
|
|
|||||||
|
Initialize the contents of a wst_StatusCodeOpenEnum. Initialize the contents of a wst_StatusCodeOpenEnum. This should be used when the structure is allocated on the stack or by a some allocator besides wst_StatusCodeOpenEnum_init(). The contents may be freed by calling wst_StatusCodeOpenEnum_destroy_contents().
Definition at line 288 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_init_contents(). Referenced by wst_StatusCodeOpenEnum_init_contents(), and wst_StatusCodeOpenEnum_init_contents_wrapper().
00290 {
00291 globus_result_t result = GLOBUS_SUCCESS;
00292 GlobusFuncName(wst_StatusCodeOpenEnum_init_contents);
00293 GlobusSoapMessageDebugEnter();
00294
00295
00296 result = xsd_anyURI_init_contents((xsd_anyURI *) instance);
00297
00298 GlobusSoapMessageDebugExit();
00299 return result;
00300 }
|
|
|||||||
|
Destroy the contents of a wst_StatusCodeOpenEnum. Destroy the subelements and attributes of the given wst_StatusCodeOpenEnum.
Definition at line 351 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_destroy_contents(). Referenced by wst_StatusCodeOpenEnum_array_copy_contents(), wst_StatusCodeOpenEnum_array_deserialize(), wst_StatusCodeOpenEnum_array_destroy_contents(), wst_StatusCodeOpenEnum_destroy(), wst_StatusCodeOpenEnum_destroy_contents(), wst_StatusCodeOpenEnum_destroy_contents_wrapper(), wst_StatusType_copy_contents(), wst_StatusType_deserialize(), wst_StatusType_deserialize_pointer(), and wst_StatusType_destroy_contents().
00353 {
00354 GlobusFuncName(wst_StatusCodeOpenEnum_destroy_contents);
00355 GlobusSoapMessageDebugEnter();
00356
00357 if(instance)
00358 {
00359
00360
00361 xsd_anyURI_destroy_contents((xsd_anyURI *)instance);
00362
00363 }
00364
00365 GlobusSoapMessageDebugExit();
00366 }
|
|
|||||||||
|
Copy the contents of a wst_StatusCodeOpenEnum. Perform a deep copy of the contents of a wst_StatusCodeOpenEnum. The dest strcuture must be allocated before making this call. A copy of the subelements and attributes of @ src will be made to dest.
Definition at line 400 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_copy_contents(). Referenced by wst_StatusCodeOpenEnum_array_copy_contents(), wst_StatusCodeOpenEnum_copy(), wst_StatusCodeOpenEnum_copy_contents(), wst_StatusCodeOpenEnum_copy_contents_wrapper(), and wst_StatusType_copy_contents().
00403 {
00404 globus_result_t result = GLOBUS_SUCCESS;
00405 GlobusFuncName(wst_StatusCodeOpenEnum_copy_contents);
00406
00407 GlobusSoapMessageDebugEnter();
00408
00409
00410 result = xsd_anyURI_copy_contents(
00411 (xsd_anyURI *)instance, (const xsd_anyURI *) src_obj);
00412 goto exit;
00413
00414 goto exit;
00415
00416 fail_copy:
00417
00418
00419 exit:
00420
00421 GlobusSoapMessageDebugExit();
00422 return result;
00423 }
|
|
|||||||
|
Initialize an array of wst_StatusCodeOpenEnum elements. Allocates a new array of 0 elements. When this array is no longer used, it should be freed by calling wst_StatusCodeOpenEnum_array_destroy().
Definition at line 939 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array, wst_StatusCodeOpenEnum_array_init(), and wst_StatusCodeOpenEnum_array_init_contents(). Referenced by wst_StatusCodeOpenEnum_array_deserialize_wrapper(), wst_StatusCodeOpenEnum_array_init(), and wst_StatusCodeOpenEnum_array_init_wrapper().
00941 {
00942 wst_StatusCodeOpenEnum_array * array;
00943 globus_result_t result;
00944 GlobusFuncName(wst_StatusCodeOpenEnum_array_init);
00945 GlobusSoapMessageDebugEnter();
00946
00947 array = (wst_StatusCodeOpenEnum_array *)
00948 globus_malloc(sizeof(wst_StatusCodeOpenEnum_array));
00949 if(!array)
00950 {
00951 result = GlobusSoapMessageErrorOutOfMemory;
00952 GlobusSoapMessageDebugExit();
00953 return result;
00954 }
00955
00956 result = wst_StatusCodeOpenEnum_array_init_contents(array);
00957 if(result != GLOBUS_SUCCESS)
00958 {
00959 globus_free(array);
00960 array = NULL;
00961
00962 }
00963
00964 *arr = array;
00965
00966 GlobusSoapMessageDebugExit();
00967 return result;
00968 }
|
|
|||||||
|
Destroy an array of wst_StatusCodeOpenEnum elements. Frees an array of wst_StatusCodeOpenEnum elements. The contents of each element element in the array be destroyed by calling wst_StatusCodeOpenEnum_destroy_contents().
Definition at line 994 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array, wst_StatusCodeOpenEnum_array_destroy(), and wst_StatusCodeOpenEnum_array_destroy_contents(). Referenced by wst_StatusCodeOpenEnum_array_destroy(), and wst_StatusCodeOpenEnum_array_destroy_wrapper().
00996 {
00997 GlobusFuncName(wst_StatusCodeOpenEnum_array_destroy);
00998 GlobusSoapMessageDebugEnter();
00999
01000 wst_StatusCodeOpenEnum_array_destroy_contents(array);
01001 globus_free(array);
01002
01003 GlobusSoapMessageDebugExit();
01004 }
|
|
|||||||||
|
Copy an array of wst_StatusCodeOpenEnum elements. Perform a deep copy of an array of wst_StatusCodeOpenEnum elements. The dest array will be allocated, and then a copy of the contents of each element in src will be made to dest.
Definition at line 1007 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array, wst_StatusCodeOpenEnum_array_copy(), and wst_StatusCodeOpenEnum_array_copy_contents(). Referenced by wst_StatusCodeOpenEnum_array_copy(), and wst_StatusCodeOpenEnum_array_copy_wrapper().
01010 {
01011 wst_StatusCodeOpenEnum_array * array;
01012 globus_result_t result;
01013 GlobusFuncName(wst_StatusCodeOpenEnum_array_copy);
01014 GlobusSoapMessageDebugEnter();
01015
01016 array = (wst_StatusCodeOpenEnum_array *) malloc(
01017 sizeof(wst_StatusCodeOpenEnum_array));
01018 if(!array)
01019 {
01020 result = GlobusSoapMessageErrorOutOfMemory;
01021 GlobusSoapMessageDebugExit();
01022 return result;
01023 }
01024
01025 result = wst_StatusCodeOpenEnum_array_copy_contents(array, src_arr);
01026 if(result != GLOBUS_SUCCESS)
01027 {
01028 globus_free(array);
01029 GlobusSoapMessageDebugExit();
01030 return result;
01031 }
01032
01033 *dest_arr = array;
01034
01035 GlobusSoapMessageDebugExit();
01036 return GLOBUS_SUCCESS;
01037 }
|
|
|||||||
|
Initialize the contents of an array of wst_StatusCodeOpenEnum elements. Initialize the contents of an array of wst_StatusCodeOpenEnum elements. Used when the array is allocated on the stack or by a some allocator besides wst_StatusCodeOpenEnum_array_init(). The contents of the array may be freed by calling wst_StatusCodeOpenEnum_array_destroy_contents().
Definition at line 926 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array, and wst_StatusCodeOpenEnum_array_init_contents(). Referenced by wst_StatusCodeOpenEnum_array_init(), wst_StatusCodeOpenEnum_array_init_contents(), and wst_StatusCodeOpenEnum_array_init_contents_wrapper().
00928 {
00929 GlobusFuncName(wst_StatusCodeOpenEnum_array_init_contents);
00930 GlobusSoapMessageDebugEnter();
00931
00932 memset(array, 0, sizeof(wst_StatusCodeOpenEnum_array));
00933
00934 GlobusSoapMessageDebugExit();
00935 return GLOBUS_SUCCESS;
00936 }
|
|
|||||||
|
Destroy the contents of an array of wst_StatusCodeOpenEnum elements. Destroy the elements in an array of wst_StatusCodeOpenEnum elements. The contents of each element in the array be destroyed by calling wst_StatusCodeOpenEnum_destroy_contents() and the array will be reset to be empty.
Definition at line 971 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array_s::elements, wst_StatusCodeOpenEnum_array_s::length, wst_StatusCodeOpenEnum_array, wst_StatusCodeOpenEnum_array_destroy_contents(), and wst_StatusCodeOpenEnum_destroy_contents(). Referenced by wst_StatusCodeOpenEnum_array_destroy(), wst_StatusCodeOpenEnum_array_destroy_contents(), and wst_StatusCodeOpenEnum_array_destroy_contents_wrapper().
00973 {
00974 int i = 0;
00975 GlobusFuncName(wst_StatusCodeOpenEnum_array_destroy_contents);
00976 GlobusSoapMessageDebugEnter();
00977
00978 for(; i < array->length; ++i)
00979 {
00980 wst_StatusCodeOpenEnum_destroy_contents(&array->elements[i]);
00981 }
00982
00983 if(array->elements)
00984 {
00985 globus_free(array->elements);
00986 array->elements = NULL;
00987 }
00988 array->length = 0;
00989
00990 GlobusSoapMessageDebugExit();
00991 }
|
|
|||||||||
|
Copy the contents of an array of wst_StatusCodeOpenEnum elements. Perform a deep copy of an array of wst_StatusCodeOpenEnum elements. The dest array must be allocated before making this call. A copy of the contents of each element in src will be made to dest.
Definition at line 1040 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array_s::elements, wst_StatusCodeOpenEnum_array_s::length, wst_StatusCodeOpenEnum, wst_StatusCodeOpenEnum_array, wst_StatusCodeOpenEnum_array_copy_contents(), wst_StatusCodeOpenEnum_copy_contents(), and wst_StatusCodeOpenEnum_destroy_contents(). Referenced by wst_StatusCodeOpenEnum_array_copy(), wst_StatusCodeOpenEnum_array_copy_contents(), and wst_StatusCodeOpenEnum_array_copy_contents_wrapper().
01043 {
01044 int i;
01045 globus_result_t result = GLOBUS_SUCCESS;
01046 GlobusFuncName(wst_StatusCodeOpenEnum_array_copy_contents);
01047 GlobusSoapMessageDebugEnter();
01048
01049 dest_arr->length = src_arr->length;
01050 if(dest_arr->length > 0)
01051 {
01052 dest_arr->elements = (wst_StatusCodeOpenEnum *) malloc(
01053 sizeof(wst_StatusCodeOpenEnum) * dest_arr->length);
01054 if(!dest_arr->elements)
01055 {
01056 result = GlobusSoapMessageErrorOutOfMemory;
01057 GlobusSoapMessageDebugExit();
01058 return result;
01059 }
01060 }
01061 else
01062 {
01063 dest_arr->elements = NULL;
01064 }
01065
01066 for(i = 0; i < dest_arr->length; i++)
01067 {
01068 result = wst_StatusCodeOpenEnum_copy_contents(
01069 &dest_arr->elements[i], &src_arr->elements[i]);
01070 if(result != GLOBUS_SUCCESS)
01071 {
01072 while(i--)
01073 {
01074 wst_StatusCodeOpenEnum_destroy_contents(&dest_arr->elements[i]);
01075 }
01076
01077 globus_free(dest_arr->elements);
01078 dest_arr->elements = NULL;
01079 dest_arr->length = 0;
01080 break;
01081 }
01082 }
01083
01084 GlobusSoapMessageDebugExit();
01085 return result;
01086 }
|
|
|||||||
|
Append a new wst_StatusCodeOpenEnum to an array. Allocate and initialize a new wst_StatusCodeOpenEnum structure, adding it to the end of the given array.
Definition at line 1089 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array_s::elements, wst_StatusCodeOpenEnum_array_s::length, wst_StatusCodeOpenEnum, wst_StatusCodeOpenEnum_array, and wst_StatusCodeOpenEnum_array_push(). Referenced by wst_StatusCodeOpenEnum_array_push(), and wst_StatusCodeOpenEnum_array_push_wrapper().
01091 {
01092 GlobusFuncName(wst_StatusCodeOpenEnum_array_push);
01093 GlobusSoapMessageDebugEnter();
01094
01095 array->elements = realloc(array->elements,
01096 sizeof(wst_StatusCodeOpenEnum) *
01097 (array->length + 1));
01098 memset(&array->elements[array->length], 0, sizeof(wst_StatusCodeOpenEnum));
01099 array->length++;
01100
01101 GlobusSoapMessageDebugExit();
01102 return (&array->elements[array->length - 1]);
01103 }
|
|
|||||||||||||||
|
Deserialize a wst_StatusCodeOpenEnum. Deserialize an element containing a wst_StatusCodeOpenEnum element.
Definition at line 766 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_deserialize(). Referenced by wst_StatusCodeOpenEnum_array_deserialize(), wst_StatusCodeOpenEnum_deserialize(), wst_StatusCodeOpenEnum_deserialize_contents(), wst_StatusType_deserialize(), and wst_StatusType_deserialize_pointer().
00771 {
00772 globus_result_t result = GLOBUS_SUCCESS;
00773 xsd_QName subelement;
00774 GlobusFuncName(wst_StatusCodeOpenEnum_deserialize);
00775 GlobusSoapMessageDebugEnter();
00776
00777
00778 if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
00779 {
00780 result = globus_soap_message_deserialize_element(
00781 message_handle, element_qname);
00782 if(result != GLOBUS_SUCCESS)
00783 {
00784 result = GlobusSoapMessageErrorDeserializeFailed(
00785 result, element_qname);
00786 goto exit;
00787 }
00788
00789 result = globus_soap_message_deserialize_element_begin_close(
00790 message_handle);
00791 if(result != GLOBUS_SUCCESS)
00792 {
00793 result = GlobusSoapMessageErrorDeserializeFailed(
00794 result, element_qname);
00795 goto fail_deserialize;
00796 }
00797 }
00798
00799 result = xsd_anyURI_deserialize_contents(
00800 NULL,
00801 (xsd_anyURI *)instance,
00802 message_handle,
00803 options);
00804 if(result != GLOBUS_SUCCESS)
00805 {
00806 result = GlobusSoapMessageErrorDeserializeFailed(
00807 result, element_qname);
00808 goto base_value_destroy;
00809 }
00810
00811 if(!(options & GLOBUS_XSD_ELEMENT_CONTENTS_ONLY))
00812 {
00813 result = globus_soap_message_deserialize_element_end(
00814 message_handle,
00815 element_qname);
00816 if(result != GLOBUS_SUCCESS)
00817 {
00818 result = GlobusSoapMessageErrorDeserializeFailed(
00819 result, element_qname);
00820 goto fail_deserialize;
00821 }
00822 }
00823
00824 goto exit;
00825
00826 fail_deserialize:
00827
00828 xsd_anyURI_destroy_contents((xsd_anyURI *)instance);
00829 base_value_destroy:
00830
00831
00832 exit:
00833
00834 GlobusSoapMessageDebugExit();
00835 return result;
00836 }
|
|
|||||||||||||||
|
Deserialize a wst_StatusCodeOpenEnum. Deserialize a wst_StatusCodeOpenEnum whose enclosing element has already been deserialized.
Definition at line 735 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_deserialize(), and wst_StatusCodeOpenEnum_deserialize_contents(). Referenced by wst_StatusCodeOpenEnum_deserialize_contents(), and wst_StatusCodeOpenEnum_deserialize_contents_wrapper().
00740 {
00741 globus_result_t result = GLOBUS_SUCCESS;
00742 GlobusFuncName(wst_StatusCodeOpenEnum_deserialize_contents);
00743 GlobusSoapMessageDebugEnter();
00744
00745 result = wst_StatusCodeOpenEnum_deserialize(
00746 NULL,
00747 inst,
00748 message_handle,
00749 options | GLOBUS_XSD_ELEMENT_CONTENTS_ONLY);
00750 if(result != GLOBUS_SUCCESS)
00751 {
00752 result = GlobusSoapMessageErrorDeserializeFailed(
00753 result, element_qname);
00754 goto exit;
00755 }
00756
00757 exit:
00758
00759 GlobusSoapMessageDebugExit();
00760 return result;
00761 }
|
|
|||||||||||||||
|
Deserialize an optional wst_StatusCodeOpenEnum. Deserialize the next element if it contains a wst_StatusCodeOpenEnum.
Definition at line 841 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum, wst_StatusCodeOpenEnum_deserialize_pointer(), and wst_StatusCodeOpenEnum_init(). Referenced by wst_StatusCodeOpenEnum_deserialize_pointer(), and wst_StatusCodeOpenEnum_deserialize_pointer_wrapper().
00846 {
00847 wst_StatusCodeOpenEnum * instance = NULL;
00848 globus_result_t result = GLOBUS_SUCCESS;
00849 xsd_QName subelement;
00850 GlobusFuncName(wst_StatusCodeOpenEnum_deserialize_pointer);
00851 GlobusSoapMessageDebugEnter();
00852
00853 *ip = NULL;
00854
00855
00856 result = globus_soap_message_deserialize_element(
00857 message_handle, element_qname);
00858 if(GlobusSoapMessageStatusElementNotFoundCheck(result) ||
00859 GlobusSoapMessageStatusFailedElementCheck(result) ||
00860 GlobusSoapMessageStatusFailedWithTextCheck(result))
00861 {
00862 *ip = NULL;
00863 result = GLOBUS_SUCCESS;
00864 goto exit;
00865 }
00866
00867 if(result != GLOBUS_SUCCESS)
00868 {
00869 result = GlobusSoapMessageErrorDeserializeFailed(
00870 result, element_qname);
00871 goto exit;
00872 }
00873
00874 if(globus_soap_message_deserialize_element_is_empty(
00875 message_handle))
00876 {
00877 *ip = NULL;
00878 goto exit;
00879 }
00880
00881 result = wst_StatusCodeOpenEnum_init(&instance);
00882 if(result != GLOBUS_SUCCESS)
00883 {
00884 result = GlobusSoapMessageErrorDeserializeFailed(
00885 result, element_qname);
00886 goto exit;
00887 }
00888
00889 result = globus_soap_message_deserialize_element_begin_close(
00890 message_handle);
00891 if(result != GLOBUS_SUCCESS)
00892 {
00893 result = GlobusSoapMessageErrorDeserializeFailed(
00894 result, element_qname);
00895 goto exit;
00896 }
00897
00898
00899
00900 result = globus_soap_message_deserialize_element_end(
00901 message_handle,
00902 element_qname);
00903 if(result != GLOBUS_SUCCESS)
00904 {
00905 result = GlobusSoapMessageErrorDeserializeFailed(
00906 result, element_qname);
00907 goto exit;
00908 }
00909
00910 *ip = instance;
00911
00912 goto exit;
00913
00914 fail_deserialize:
00915
00916
00917 exit:
00918
00919 GlobusSoapMessageDebugExit();
00920 return result;
00921 }
|
|
|||||||||||||||
|
Serialize an array of wst_StatusCodeOpenEnum elements. Serialize an element containing an array of wst_StatusCodeOpenEnum elements.
Definition at line 1113 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array_s::elements, wst_StatusCodeOpenEnum_array_s::length, wst_StatusCodeOpenEnum_array, wst_StatusCodeOpenEnum_array_serialize(), and wst_StatusCodeOpenEnum_serialize(). Referenced by wst_StatusCodeOpenEnum_array_serialize(), and wst_StatusCodeOpenEnum_array_serialize_wrapper().
01118 {
01119 globus_result_t result = GLOBUS_SUCCESS;
01120 int i = 0;
01121 GlobusFuncName(wst_StatusCodeOpenEnum_array_serialize);
01122 GlobusSoapMessageDebugEnter();
01123
01124 for(; i < array->length; ++i)
01125 {
01126 result = wst_StatusCodeOpenEnum_serialize(
01127 element_qname,
01128 &array->elements[i],
01129 message,
01130 options);
01131 if(result != GLOBUS_SUCCESS)
01132 {
01133 goto exit;
01134 }
01135 }
01136
01137 exit:
01138
01139 GlobusSoapMessageDebugExit();
01140 return result;
01141 }
|
|
|||||||||||||||
|
Deserialize an array of wst_StatusCodeOpenEnum elements. Deserialize an element containing an array of wst_StatusCodeOpenEnum elements.
Definition at line 1144 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_array_s::elements, wst_StatusCodeOpenEnum_array_s::length, wst_StatusCodeOpenEnum, wst_StatusCodeOpenEnum_array, wst_StatusCodeOpenEnum_array_deserialize(), wst_StatusCodeOpenEnum_deserialize(), and wst_StatusCodeOpenEnum_destroy_contents(). Referenced by wst_StatusCodeOpenEnum_array_deserialize(), and wst_StatusCodeOpenEnum_array_deserialize_wrapper().
01149 {
01150 globus_result_t result = GLOBUS_SUCCESS;
01151 int i = 0;
01152 int pre_length;
01153 GlobusFuncName(wst_StatusCodeOpenEnum_array_deserialize);
01154 GlobusSoapMessageDebugEnter();
01155
01156 pre_length = array->length;
01157
01158 for(i = 0; i < pre_length; ++i)
01159 {
01160 result = wst_StatusCodeOpenEnum_deserialize(
01161 element_qname,
01162 &array->elements[i],
01163 message,
01164 options);
01165 if(result != GLOBUS_SUCCESS)
01166 {
01167 if(GlobusSoapMessageStatusFailedElementCheck(result) ||
01168 GlobusSoapMessageStatusElementNotFoundCheck(result) ||
01169 GlobusSoapMessageStatusFailedWithTextCheck(result))
01170 {
01171 result = GLOBUS_SUCCESS;
01172 break;
01173 }
01174
01175 result = GlobusSoapMessageErrorDeserializeFailed(
01176 result, element_qname);
01177 goto exit;
01178 }
01179 }
01180
01181 while(result == GLOBUS_SUCCESS)
01182 {
01183 wst_StatusCodeOpenEnum next;
01184 memset(&next, 0, sizeof(wst_StatusCodeOpenEnum));
01185
01186 result = wst_StatusCodeOpenEnum_deserialize(
01187 element_qname,
01188 &next,
01189 message,
01190 options);
01191 if(result != GLOBUS_SUCCESS)
01192 {
01193 if(GlobusSoapMessageStatusFailedElementCheck(result) ||
01194 GlobusSoapMessageStatusElementNotFoundCheck(result) ||
01195 GlobusSoapMessageStatusFailedWithTextCheck(result))
01196 {
01197 result = GLOBUS_SUCCESS;
01198 break;
01199 }
01200
01201 result = GlobusSoapMessageErrorDeserializeFailed(
01202 result, element_qname);
01203 goto exit;
01204 }
01205
01206 array->elements = realloc(
01207 array->elements,
01208 (array->length + 1) * sizeof(wst_StatusCodeOpenEnum));
01209 if(!array->elements)
01210 {
01211 result = GlobusSoapMessageErrorOutOfMemory;
01212 goto exit;
01213 }
01214 array->elements[array->length] = next;
01215 array->length++;
01216 ++i;
01217 }
01218
01219 exit:
01220
01221 if(result != GLOBUS_SUCCESS)
01222 {
01223 int di = 0;
01224 for(; di < i; ++di)
01225 {
01226 wst_StatusCodeOpenEnum_destroy_contents(
01227 &array->elements[di]);
01228 memset(&array->elements[di], 0, sizeof(wst_StatusCodeOpenEnum));
01229 }
01230 }
01231
01232 GlobusSoapMessageDebugExit();
01233 return result;
01234 }
|
|
|||||||||||||||
|
Deserialize an attribute of type wst_StatusCodeOpenEnum. Deserialize a wst_StatusCodeOpenEnum as an attribute of the current element.
Definition at line 1265 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_deserialize_attribute(). Referenced by wst_StatusCodeOpenEnum_deserialize_attribute().
01270 {
01271 globus_result_t result = GLOBUS_SUCCESS;
01272 GlobusFuncName(wst_StatusCodeOpenEnum_deserialize_attribute);
01273 GlobusSoapMessageDebugEnter();
01274
01275
01276 result = xsd_anyURI_deserialize_attribute(
01277 attr_qname, (xsd_anyURI *)instance, message, options);
01278
01279 if(result != GLOBUS_SUCCESS)
01280 {
01281 result = GlobusSoapMessageErrorDeserializeFailed(
01282 result, attr_qname);
01283 goto exit;
01284 }
01285
01286 exit:
01287
01288 GlobusSoapMessageDebugExit();
01289 return result;
01290 }
|
|
|||||||||||||||
|
Deserialize an optional attribute of type wst_StatusCodeOpenEnum. Try to deserialize a wst_StatusCodeOpenEnum as an attribute of the current element if it is present. The attribute's name is defined by @ attr_qname.
Definition at line 1293 of file wst_StatusCodeOpenEnum.c. References wst_StatusCodeOpenEnum_deserialize_attribute_pointer(). Referenced by wst_StatusCodeOpenEnum_deserialize_attribute_pointer().
01298 {
01299 globus_result_t result = GLOBUS_SUCCESS;
01300 GlobusFuncName(wst_StatusCodeOpenEnum_deserialize_attribute_pointer);
01301 GlobusSoapMessageDebugEnter();
01302
01303
01304 result = xsd_anyURI_deserialize_attribute_pointer(
01305 attr_qname, (xsd_anyURI **)instance, message, options);
01306
01307 if(result != GLOBUS_SUCCESS)
01308 {
01309 result = GlobusSoapMessageErrorDeserializeFailed(
01310 result, attr_qname);
01311 goto exit;
01312 }
01313
01314 exit:
01315
01316 GlobusSoapMessageDebugExit();
01317 return result;
01318 }
|
|
||
|
||
|
Initial value:
{
"http://schemas.xmlsoap.org/ws/2004/04/trust",
"StatusCodeOpenEnum"
}
Definition at line 22 of file wst_StatusCodeOpenEnum.c. Referenced by wst_StatusCodeOpenEnum_serialize(), wst_StatusType_copy_contents(), wst_StatusType_deserialize(), wst_StatusType_deserialize_pointer(), and wst_StatusType_serialize(). |
|
||
|
QName of the wst_StatusCodeOpenEnum complex type.
Definition at line 79 of file wst_StatusCodeOpenEnum.h. Referenced by wst_StatusCodeOpenEnum_serialize(), wst_StatusType_copy_contents(), wst_StatusType_deserialize(), wst_StatusType_deserialize_pointer(), and wst_StatusType_serialize(). |
|
||
|
Initial value:
{
&wst_StatusCodeOpenEnum_qname,
wst_StatusCodeOpenEnum_serialize_wrapper,
wst_StatusCodeOpenEnum_deserialize_pointer_wrapper,
wst_StatusCodeOpenEnum_init_wrapper,
wst_StatusCodeOpenEnum_destroy_wrapper,
wst_StatusCodeOpenEnum_copy_wrapper,
wst_StatusCodeOpenEnum_init_contents_wrapper,
wst_StatusCodeOpenEnum_destroy_contents_wrapper,
wst_StatusCodeOpenEnum_copy_contents_wrapper,
sizeof(wst_StatusCodeOpenEnum),
NULL,
&wst_StatusCodeOpenEnum_contents_info,
&wst_StatusCodeOpenEnum_array_info
}
Definition at line 270 of file wst_StatusCodeOpenEnum.c. |
|
||
|
Type information for serializing and deserializing wst_StatusCodeOpenEnum elements.
Definition at line 84 of file wst_StatusCodeOpenEnum.h. |
|
||
|
Initial value:
{
&wst_StatusCodeOpenEnum_qname,
wst_StatusCodeOpenEnum_array_serialize_wrapper,
wst_StatusCodeOpenEnum_array_deserialize_wrapper,
wst_StatusCodeOpenEnum_array_init_wrapper,
wst_StatusCodeOpenEnum_array_destroy_wrapper,
wst_StatusCodeOpenEnum_array_copy_wrapper,
wst_StatusCodeOpenEnum_array_init_contents_wrapper,
wst_StatusCodeOpenEnum_array_destroy_contents_wrapper,
wst_StatusCodeOpenEnum_array_copy_contents_wrapper,
sizeof(wst_StatusCodeOpenEnum),
wst_StatusCodeOpenEnum_array_push_wrapper,
NULL,
NULL
}
Definition at line 236 of file wst_StatusCodeOpenEnum.c. |
|
||
|
Type information for serializing and deserializing arrays of wst_StatusCodeOpenEnum elements.
Definition at line 90 of file wst_StatusCodeOpenEnum.h. |
|
||
|
Initial value:
{
&wst_StatusCodeOpenEnum_qname,
wst_StatusCodeOpenEnum_serialize_contents_wrapper,
wst_StatusCodeOpenEnum_deserialize_contents_wrapper,
wst_StatusCodeOpenEnum_init_wrapper,
wst_StatusCodeOpenEnum_destroy_wrapper,
wst_StatusCodeOpenEnum_copy_wrapper,
wst_StatusCodeOpenEnum_init_contents_wrapper,
wst_StatusCodeOpenEnum_destroy_contents_wrapper,
wst_StatusCodeOpenEnum_copy_contents_wrapper,
sizeof(wst_StatusCodeOpenEnum),
NULL,
NULL,
NULL
}
Definition at line 253 of file wst_StatusCodeOpenEnum.c. |
|
||
|
Type information for serializing and deserializing the contents of wst_StatusCodeOpenEnum without surrounding elements.
Definition at line 96 of file wst_StatusCodeOpenEnum.h. |
about globus |
grid research |
globus toolkit |
software development
Comments? webmaster@globus.org