lock.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
#ifndef __PJ_LOCK_H__
#define __PJ_LOCK_H__
 
#include <pj/types.h>
 
PJ_BEGIN_DECL
 
PJ_DECL(pj_status_t) pj_lock_create_simple_mutex( pj_pool_t *pool,
                                                  const char *name,
                                                  pj_lock_t **lock );
 
PJ_DECL(pj_status_t) pj_lock_create_recursive_mutex( pj_pool_t *pool,
                                                     const char *name,
                                                     pj_lock_t **lock );
 
 
PJ_DECL(pj_status_t) pj_lock_create_null_mutex( pj_pool_t *pool,
                                                const char *name,
                                                pj_lock_t **lock );
 
 
#if defined(PJ_HAS_SEMAPHORE) && PJ_HAS_SEMAPHORE != 0
PJ_DECL(pj_status_t) pj_lock_create_semaphore( pj_pool_t *pool,
                                               const char *name,
                                               unsigned initial,
                                               unsigned max,
                                               pj_lock_t **lock );
 
#endif  /* PJ_HAS_SEMAPHORE */
 
PJ_DECL(pj_status_t) pj_lock_acquire( pj_lock_t *lock );
 
 
PJ_DECL(pj_status_t) pj_lock_tryacquire( pj_lock_t *lock );
 
 
PJ_DECL(pj_status_t) pj_lock_release( pj_lock_t *lock );
 
 
PJ_DECL(pj_status_t) pj_lock_destroy( pj_lock_t *lock );
 
 
typedef struct pj_grp_lock_config
{
    unsigned    flags;
 
} pj_grp_lock_config;
 
 
typedef void (*pj_grp_lock_handler)(void *member);
 
 
PJ_DECL(void) pj_grp_lock_config_default(pj_grp_lock_config *cfg);
 
PJ_DECL(pj_status_t) pj_grp_lock_create(pj_pool_t *pool,
                                        const pj_grp_lock_config *cfg,
                                        pj_grp_lock_t **p_grp_lock);
 
PJ_DECL(pj_status_t) pj_grp_lock_create_w_handler(pj_pool_t *pool,
                                                  const pj_grp_lock_config *cfg,
                                                  void *member,
                                                  pj_grp_lock_handler handler,
                                                  pj_grp_lock_t **p_grp_lock);
 
PJ_DECL(pj_status_t) pj_grp_lock_destroy( pj_grp_lock_t *grp_lock);
 
PJ_DECL(pj_status_t) pj_grp_lock_replace(pj_grp_lock_t *old_lock,
                                         pj_grp_lock_t *new_lock);
 
PJ_DECL(pj_status_t) pj_grp_lock_acquire( pj_grp_lock_t *grp_lock);
 
PJ_DECL(pj_status_t) pj_grp_lock_tryacquire( pj_grp_lock_t *grp_lock);
 
PJ_DECL(pj_status_t) pj_grp_lock_release( pj_grp_lock_t *grp_lock);
 
PJ_DECL(pj_status_t) pj_grp_lock_add_handler(pj_grp_lock_t *grp_lock,
                                             pj_pool_t *pool,
                                             void *member,
                                             pj_grp_lock_handler handler);
 
PJ_DECL(pj_status_t) pj_grp_lock_del_handler(pj_grp_lock_t *grp_lock,
                                             void *member,
                                             pj_grp_lock_handler handler);
 
#if !PJ_GRP_LOCK_DEBUG
PJ_DECL(pj_status_t) pj_grp_lock_add_ref(pj_grp_lock_t *grp_lock);
 
#define pj_grp_lock_add_ref_dbg(grp_lock, x, y) pj_grp_lock_add_ref(grp_lock)
 
#else
 
#define pj_grp_lock_add_ref(g)  pj_grp_lock_add_ref_dbg(g, __FILE__, __LINE__)
 
PJ_DECL(pj_status_t) pj_grp_lock_add_ref_dbg(pj_grp_lock_t *grp_lock,
                                             const char *file,
                                             int line);
#endif
 
#if !PJ_GRP_LOCK_DEBUG
PJ_DECL(pj_status_t) pj_grp_lock_dec_ref(pj_grp_lock_t *grp_lock);
 
#define pj_grp_lock_dec_ref_dbg(grp_lock, x, y) pj_grp_lock_dec_ref(grp_lock)
#else
 
#define pj_grp_lock_dec_ref(g)  pj_grp_lock_dec_ref_dbg(g, __FILE__, __LINE__)
 
PJ_DECL(pj_status_t) pj_grp_lock_dec_ref_dbg(pj_grp_lock_t *grp_lock,
                                             const char *file,
                                             int line);
 
#endif
 
PJ_DECL(int) pj_grp_lock_get_ref(pj_grp_lock_t *grp_lock);
 
 
PJ_DECL(void) pj_grp_lock_dump(pj_grp_lock_t *grp_lock);
 
 
PJ_DECL(pj_status_t) pj_grp_lock_chain_lock(pj_grp_lock_t *grp_lock,
                                            pj_lock_t *ext_lock,
                                            int pos);
 
PJ_DECL(pj_status_t) pj_grp_lock_unchain_lock(pj_grp_lock_t *grp_lock,
                                              pj_lock_t *ext_lock);
 
 
PJ_END_DECL
 
 
#endif  /* __PJ_LOCK_H__ */