Return to blocking_queue.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / collections

Annotation of embedaddon/strongswan/src/libstrongswan/collections/blocking_queue.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Copyright (C) 2012 Tobias Brunner
        !             3:  * Copyright (C) 2012 Giuliano Grassi
        !             4:  * Copyright (C) 2012 Ralf Sager
        !             5:  * HSR Hochschule fuer Technik Rapperswil
        !             6:  *
        !             7:  * This program is free software; you can redistribute it and/or modify it
        !             8:  * under the terms of the GNU General Public License as published by the
        !             9:  * Free Software Foundation; either version 2 of the License, or (at your
        !            10:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
        !            11:  *
        !            12:  * This program is distributed in the hope that it will be useful, but
        !            13:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            14:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
        !            15:  * for more details.
        !            16:  */
        !            17: 
        !            18: #include "blocking_queue.h"
        !            19: 
        !            20: #include <threading/mutex.h>
        !            21: #include <threading/thread.h>
        !            22: #include <threading/condvar.h>
        !            23: #include <collections/linked_list.h>
        !            24: 
        !            25: typedef struct private_blocking_queue_t private_blocking_queue_t;
        !            26: 
        !            27: /**
        !            28:  * Private data of a blocking_queue_t object.
        !            29:  */
        !            30: struct private_blocking_queue_t {
        !            31: 
        !            32:        /**
        !            33:         * Public part
        !            34:         */
        !            35:        blocking_queue_t public;
        !            36: 
        !            37:        /**
        !            38:         * Linked list containing all items in the queue
        !            39:         */
        !            40:        linked_list_t *list;
        !            41: 
        !            42:        /**
        !            43:         * Mutex used to synchronize access to the queue
        !            44:         */
        !            45:        mutex_t *mutex;
        !            46: 
        !            47:        /**
        !            48:         * Condvar used to wait for items
        !            49:         */
        !            50:        condvar_t *condvar;
        !            51: 
        !            52: };
        !            53: 
        !            54: METHOD(blocking_queue_t, enqueue, void,
        !            55:        private_blocking_queue_t *this, void *item)
        !            56: {
        !            57:        this->mutex->lock(this->mutex);
        !            58:        this->list->insert_first(this->list, item);
        !            59:        this->condvar->signal(this->condvar);
        !            60:        this->mutex->unlock(this->mutex);
        !            61: }
        !            62: 
        !            63: METHOD(blocking_queue_t, dequeue, void*,
        !            64:        private_blocking_queue_t *this)
        !            65: {
        !            66:        bool oldstate;
        !            67:        void *item;
        !            68: 
        !            69: 
        !            70:        this->mutex->lock(this->mutex);
        !            71:        thread_cleanup_push((thread_cleanup_t)this->mutex->unlock, this->mutex);
        !            72:        /* ensure that a canceled thread does not dequeue any items */
        !            73:        thread_cancellation_point();
        !            74:        while (this->list->remove_last(this->list, &item) != SUCCESS)
        !            75:        {
        !            76:                oldstate = thread_cancelability(TRUE);
        !            77:                this->condvar->wait(this->condvar, this->mutex);
        !            78:                thread_cancelability(oldstate);
        !            79:        }
        !            80:        thread_cleanup_pop(TRUE);
        !            81:        return item;
        !            82: }
        !            83: 
        !            84: METHOD(blocking_queue_t, destroy, void,
        !            85:        private_blocking_queue_t *this)
        !            86: {
        !            87:        this->list->destroy(this->list);
        !            88:        this->condvar->destroy(this->condvar);
        !            89:        this->mutex->destroy(this->mutex);
        !            90:        free(this);
        !            91: }
        !            92: 
        !            93: METHOD(blocking_queue_t, destroy_offset, void,
        !            94:        private_blocking_queue_t *this, size_t offset)
        !            95: {
        !            96:        this->list->invoke_offset(this->list, offset);
        !            97:        destroy(this);
        !            98: }
        !            99: 
        !           100: METHOD(blocking_queue_t, destroy_function, void,
        !           101:        private_blocking_queue_t *this, void (*fn)(void*))
        !           102: {
        !           103:        this->list->invoke_function(this->list, (linked_list_invoke_t)fn);
        !           104:        destroy(this);
        !           105: }
        !           106: 
        !           107: /*
        !           108:  * Described in header.
        !           109:  */
        !           110: blocking_queue_t *blocking_queue_create()
        !           111: {
        !           112:        private_blocking_queue_t *this;
        !           113: 
        !           114:        INIT(this,
        !           115:                .public = {
        !           116:                        .enqueue = _enqueue,
        !           117:                        .dequeue = _dequeue,
        !           118:                        .destroy = _destroy,
        !           119:                        .destroy_offset = _destroy_offset,
        !           120:                        .destroy_function = _destroy_function,
        !           121:                },
        !           122:                .list = linked_list_create(),
        !           123:                .mutex = mutex_create(MUTEX_TYPE_DEFAULT),
        !           124:                .condvar = condvar_create(CONDVAR_TYPE_DEFAULT),
        !           125:        );
        !           126: 
        !           127:        return &this->public;
        !           128: }
        !           129: