globus_i_callback.h

00001 /*
00002  * Copyright 1999-2006 University of Chicago
00003  * 
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  * 
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  * 
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00017 #ifndef GLOBUS_I_CALLBACK_H
00018 #define GLOBUS_I_CALLBACK_H
00019 
00020 #include "globus_error.h"
00021 #include "globus_error_generic.h"
00022 
00023 extern globus_module_descriptor_t globus_i_callback_module_nonthreaded;
00024 extern globus_module_descriptor_t globus_i_callback_module_threaded;
00025 
00026 #define GLOBUS_CALLBACK_NONTHREADED_MODULE (&globus_i_callback_module_nonthreaded)
00027 #define GLOBUS_CALLBACK_THREADED_MODULE (&globus_i_callback_module_threaded)
00028 /* common error objects */
00029 
00030 #define GLOBUS_L_CALLBACK_CONSTRUCT_INVALID_CALLBACK_HANDLE(func)           \
00031     globus_error_put(                                                       \
00032         globus_error_construct_error(                                       \
00033             GLOBUS_CALLBACK_MODULE,                                         \
00034             GLOBUS_NULL,                                                    \
00035             GLOBUS_CALLBACK_ERROR_INVALID_CALLBACK_HANDLE,                  \
00036             __FILE__,                                                       \
00037             (func),                                                         \
00038             __LINE__,                                                       \
00039             "Invalid callback handle"))
00040 
00041 #define GLOBUS_L_CALLBACK_CONSTRUCT_INVALID_SPACE(func)                     \
00042     globus_error_put(                                                       \
00043         globus_error_construct_error(                                       \
00044             GLOBUS_CALLBACK_MODULE,                                         \
00045             GLOBUS_NULL,                                                    \
00046             GLOBUS_CALLBACK_ERROR_INVALID_SPACE,                            \
00047             __FILE__,                                                       \
00048             (func),                                                         \
00049             __LINE__,                                                       \
00050             "Invalid space handle"))
00051 
00052 #define GLOBUS_L_CALLBACK_CONSTRUCT_MEMORY_ALLOC(func, alloc)               \
00053     globus_error_put(                                                       \
00054         globus_error_construct_error(                                       \
00055             GLOBUS_CALLBACK_MODULE,                                         \
00056             GLOBUS_NULL,                                                    \
00057             GLOBUS_CALLBACK_ERROR_MEMORY_ALLOC,                             \
00058             __FILE__,                                                       \
00059             (func),                                                         \
00060             __LINE__,                                                       \
00061             "Could not allocate memory for %s",                             \
00062             (alloc)))
00063 
00064 #define GLOBUS_L_CALLBACK_CONSTRUCT_INVALID_ARGUMENT(func, argument)        \
00065     globus_error_put(                                                       \
00066         globus_error_construct_error(                                       \
00067             GLOBUS_CALLBACK_MODULE,                                         \
00068             GLOBUS_NULL,                                                    \
00069             GLOBUS_CALLBACK_ERROR_INVALID_ARGUMENT,                         \
00070             __FILE__,                                                       \
00071             (func),                                                         \
00072             __LINE__,                                                       \
00073             "Invalid argument: %s",                                         \
00074             (argument)))
00075 
00076 #define GLOBUS_L_CALLBACK_CONSTRUCT_ALREADY_CANCELED(func)                  \
00077     globus_error_put(                                                       \
00078         globus_error_construct_error(                                       \
00079             GLOBUS_CALLBACK_MODULE,                                         \
00080             GLOBUS_NULL,                                                    \
00081             GLOBUS_CALLBACK_ERROR_ALREADY_CANCELED,                         \
00082             __FILE__,                                                       \
00083             (func),                                                         \
00084             __LINE__,                                                       \
00085             "Callback previoulsy unregistered"))
00086 
00087 #define GLOBUS_L_CALLBACK_CONSTRUCT_NO_ACTIVE_CALLBACK(func)                \
00088     globus_error_put(                                                       \
00089         globus_error_construct_error(                                       \
00090             GLOBUS_CALLBACK_MODULE,                                         \
00091             GLOBUS_NULL,                                                    \
00092             GLOBUS_CALLBACK_ERROR_NO_ACTIVE_CALLBACK,                       \
00093             __FILE__,                                                       \
00094             (func),                                                         \
00095             __LINE__,                                                       \
00096             "No cuurently running callback"))
00097 
00098 #define GlobusICallbackReadyInit(queue)                                     \
00099     do {                                                                    \
00100         (queue)->head = GLOBUS_NULL;                                        \
00101         (queue)->tail = &(queue)->head;                                     \
00102     } while(0)
00103     
00104 #define GlobusICallbackReadyEnqueue(queue, callback_info)                   \
00105     do {                                                                    \
00106         (callback_info)->next = GLOBUS_NULL;                                \
00107         *(queue)->tail = callback_info;                                     \
00108         (queue)->tail = &callback_info->next;                               \
00109     } while(0)
00110 
00111 #define GlobusICallbackReadyEnqueueFirst(queue, callback_info)              \
00112     do {                                                                    \
00113         (callback_info)->next = (queue)->head;                              \
00114         if(!(queue)->head)                                                  \
00115         {                                                                   \
00116             (queue)->tail = &callback_info->next;                           \
00117         }                                                                   \
00118         (queue)->head = (callback_info);                                    \
00119     } while(0)
00120 
00121 #define GlobusICallbackReadyDequeue(queue, callback_info)                   \
00122     do {                                                                    \
00123         (callback_info) = (queue)->head;                                    \
00124         if((callback_info))                                                 \
00125         {                                                                   \
00126             (queue)->head = (callback_info)->next;                          \
00127             if(!(queue)->head)                                              \
00128             {                                                               \
00129                 (queue)->tail = &(queue)->head;                             \
00130             }                                                               \
00131         }                                                                   \
00132     } while(0)
00133 
00134 #define GlobusICallbackReadyPeak(queue, callback_info)                      \
00135     do {                                                                    \
00136         (callback_info) = (queue)->head;                                    \
00137     } while(0)
00138 
00139 #define GlobusICallbackReadyRemove(queue, callback_info)                    \
00140     do {                                                                    \
00141         globus_l_callback_info_t **     tmp;                                \
00142                                                                             \
00143         tmp = &(queue)->head;                                               \
00144         while(*tmp && *tmp != (callback_info))                              \
00145         {                                                                   \
00146             tmp = &(*tmp)->next;                                            \
00147         }                                                                   \
00148                                                                             \
00149         if(*tmp)                                                            \
00150         {                                                                   \
00151             if(!(callback_info)->next)                                      \
00152             {                                                               \
00153                 (queue)->tail = tmp;                                        \
00154             }                                                               \
00155             *tmp = (*tmp)->next;                                            \
00156         }                                                                   \
00157     } while(0)
00158     
00159 #endif /* GLOBUS_I_CALLBACK_H */

Generated on 17 Mar 2017 for globus_common by  doxygen 1.4.7