src/include/eina_lock.h

   1 /* EINA - EFL data type library
   2  * Copyright (C) 2011 Vincent Torri
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library;
  16  * if not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #ifndef EINA_LOCK_H_
  20 #define EINA_LOCK_H_
  21
  22 #include "eina_config.h"
  23 #include "eina_types.h"
  24 #include "eina_error.h"
  25
  26 /**
  27  * @addtogroup Eina_Tools_Group Tools
  28  *
  29  * @{
  30  */
  31
  32 /**
  33  * @defgroup Eina_Lock_Group Lock
  34  *
  35  * @{
  36  */
  37
  38 typedef enum
  39 {
  40    EINA_LOCK_FAIL     = EINA_FALSE,
  41    EINA_LOCK_SUCCEED  = EINA_TRUE,
  42    EINA_LOCK_DEADLOCK
  43 } Eina_Lock_Result;
  44
  45 #ifdef EINA_HAVE_THREADS
  46 # ifdef _WIN32_WCE
  47 #  include "eina_inline_lock_wince.x"
  48 # elif defined(_WIN32)
  49 #  include "eina_inline_lock_win32.x"
  50 # else
  51 #  include "eina_inline_lock_posix.x"
  52 # endif
  53 #else
  54 # include "eina_inline_lock_void.x"
  55 #endif
  56
  57 EAPI extern Eina_Error EINA_ERROR_NOT_MAIN_LOOP;
  58
  59 /** @relates static Eina_Bool eina_lock_new(_Eina_Lock *mutex) */
  60 static inline Eina_Bool eina_lock_new(Eina_Lock *mutex);
  61 /** @relates static void eina_lock_free(_Eina_Lock *mutex) */
  62 static inline void eina_lock_free(Eina_Lock *mutex);
  63 /** @relates static Eina_Lock_Result eina_lock_take(_Eina_Lock *mutex) */
  64 static inline Eina_Lock_Result eina_lock_take(Eina_Lock *mutex);
  65 /** @relates static Eina_Lock_Result eina_lock_take_try(_Eina_Lock *mutex) */
  66 static inline Eina_Lock_Result eina_lock_take_try(Eina_Lock *mutex);
  67 /** @relates static Eina_Lock_Result eina_lock_release(_Eina_Lock *mutex) */
  68 static inline Eina_Lock_Result eina_lock_release(Eina_Lock *mutex);
  69 /** @relates static void eina_lock_debug(const _Eina_Lock *mutex) */
  70 static inline void eina_lock_debug(const Eina_Lock *mutex);
  71
  72 /** @relates static Eina_Bool eina_condition_new(_Eina_Condition *cond, _Eina_Lock *mutex) */
  73 static inline Eina_Bool eina_condition_new(Eina_Condition *cond, Eina_Lock *mutex);
  74 /** @relates static void eina_condition_free(_Eina_Condition *cond) */
  75 static inline void eina_condition_free(Eina_Condition *cond);
  76 /** @relates static Eina_Bool eina_condition_wait(_Eina_Condition *cond) */
  77 static inline Eina_Bool eina_condition_wait(Eina_Condition *cond);
  78 /** @relates static Eina_Bool eina_condition_timedwait(_Eina_Condition *cond, double t) */
  79 static inline Eina_Bool eina_condition_timedwait(Eina_Condition *cond, double t);
  80 /** @relates static Eina_Bool eina_condition_broadcast(_Eina_Condition *cond) */
  81 static inline Eina_Bool eina_condition_broadcast(Eina_Condition *cond);
  82 /** @relates static Eina_Bool eina_condition_signal(_Eina_Condition *cond) */
  83 static inline Eina_Bool eina_condition_signal(Eina_Condition *cond);
  84
  85 /** @relates static Eina_Bool eina_rwlock_new(_Eina_RWLock *mutex) */
  86 static inline Eina_Bool eina_rwlock_new(Eina_RWLock *mutex);
  87 /** @relates static void eina_rwlock_free(_Eina_RWLock *mutex) */
  88 static inline void eina_rwlock_free(Eina_RWLock *mutex);
  89 /** @relates static Eina_Lock_Result eina_rwlock_take_read(_Eina_RWLock *mutex) */
  90 static inline Eina_Lock_Result eina_rwlock_take_read(Eina_RWLock *mutex);
  91 /** @relates static Eina_Lock_Result eina_rwlock_take_write(_Eina_RWLock *mutex) */
  92 static inline Eina_Lock_Result eina_rwlock_take_write(Eina_RWLock *mutex);
  93 /** @relates static Eina_Lock_Result eina_rwlock_release(_Eina_RWLock *mutex) */
  94 static inline Eina_Lock_Result eina_rwlock_release(Eina_RWLock *mutex);
  95
  96 /** @relates static Eina_Bool eina_tls_new(pthread_key_t *key) */
  97 static inline Eina_Bool eina_tls_new(Eina_TLS *key);
  98 /** @relates static void eina_tls_free(pthread_key_t key) */
  99 static inline void eina_tls_free(Eina_TLS key);
 100 /** @relates static void eina_tls_get(pthread_key_t key) */
 101 static inline void *eina_tls_get(Eina_TLS key);
 102 /** @relates static Eina_Bool eina_tls_set(pthread_key_t key, const void *data) */
 103 static inline Eina_Bool eina_tls_set(Eina_TLS key, const void *data);
 104 /** @relates static Eina_Bool eina_semaphore_new(sem_t *sem, int count_init) */
 105 static inline Eina_Bool eina_semaphore_new(Eina_Semaphore *sem, int count_init);
 106 /** @relates static Eina_Bool eina_semaphore_free(sem_t *sem) */
 107 static inline Eina_Bool eina_semaphore_free(Eina_Semaphore *sem);
 108 /** @relates static Eina_Bool eina_semaphore_lock(sem_t *sem) */
 109 static inline Eina_Bool eina_semaphore_lock(Eina_Semaphore *sem);
 110 /** @relates static Eina_Bool eina_semaphore_release(sem_t *sem, int count_release) */
 111 static inline Eina_Bool eina_semaphore_release(Eina_Semaphore *sem, int count_release);
 112
 113 #ifdef EINA_HAVE_DEBUG_THREADS
 114 # define EINA_MAIN_LOOP_CHECK_RETURN_VAL(val)                           \
 115   do {                                                                  \
 116     if (EINA_UNLIKELY(!eina_main_loop_is()))                            \
 117       {                                                                 \
 118         eina_error_set(EINA_ERROR_NOT_MAIN_LOOP);                       \
 119         EINA_LOG_ERR("You are calling %s from outside"                  \
 120                      "of the main loop threads in %s at line %i",       \
 121                      __FUNCTION__,                                      \
 122                      __FILE__,                                          \
 123                      __LINE__);                                         \
 124         return val;                                                     \
 125       }                                                                 \
 126   } while (0)
 127 # define EINA_MAIN_LOOP_CHECK_RETURN                                    \
 128   do {                                                                  \
 129     if (EINA_UNLIKELY(!eina_main_loop_is()))                            \
 130       {                                                                 \
 131         eina_error_set(EINA_ERROR_NOT_MAIN_LOOP);                       \
 132         EINA_LOG_ERR("You are calling %s from outside"                  \
 133                      "of the main loop threads in %s at line %i",       \
 134                      __FUNCTION__,                                      \
 135                      __FILE__,                                          \
 136                      __LINE__);                                         \
 137         return ;                                                        \
 138       }                                                                 \
 139   } while (0)
 140 #else
 141 /**
 142  * @def EINA_MAIN_LOOP_CHECK_RETURN_VAL
 143  * @brief The macro doesn't do anything unless EINA_HAVE_DEBUG_THREADS is defined.
 144  * @param val The value to be returned.
 145  */
 146 # define EINA_MAIN_LOOP_CHECK_RETURN_VAL(val)
 147 /**
 148  * @def EINA_MAIN_LOOP_CHECK_RETURN
 149  * @brief The macro doesn't do anything unless EINA_HAVE_DEBUG_THREADS is defined.
 150  */
 151 # define EINA_MAIN_LOOP_CHECK_RETURN
 152 #endif
 153
 154 /**
 155  * @}
 156  */
 157
 158 /**
 159  * @}
 160  */
 161
 162 #endif