SafeQueue.h

Go to the documentation of this file.

 
#ifndef SAFE_QUEUE_H_
#define SAFE_QUEUE_H_
 
 
#include <string.h>
#include <vector>
 
 
#include <WppGuard.h>
#define SQ_GUARD_CREATE(name)       wpp::WppGuard name
#define SQ_GUARD_LOCK(name)         name.lock()
#define SQ_GUARD_UNLOCK(name)       name.unlock()
#define SQ_GUARD_TRY_LOCK(name)     name.try_lock()
 
 
#define SAFE_QUEUE_DEF_ELEM_CNT 0x01
 
 
template <typename T, size_t SIZE>
class SafeQueue {
public:
    SafeQueue() {}
 
    bool push(const T * const data, size_t elements_cnt = SAFE_QUEUE_DEF_ELEM_CNT);
 
    bool pop(size_t elements_cnt = SAFE_QUEUE_DEF_ELEM_CNT);
 
    std::vector<T> to_vector(size_t elements_cnt = SIZE);
 
    T* front();
 
    T* back();
 
    T* at(size_t i);
 
    bool front(T* data);
 
    bool back(T* data);
 
    bool at(size_t i, T* data);
 
    void clear();
 
    bool is_empty();
 
    bool is_full();
 
    size_t size();
 
    size_t available_space();
 
    uint32_t element_size();
    
private:
    inline size_t _get_next_index(size_t base_index, size_t elements_cnt = SAFE_QUEUE_DEF_ELEM_CNT);
    inline size_t _get_prev_index(size_t base_index, size_t elements_cnt = SAFE_QUEUE_DEF_ELEM_CNT);
 
    inline bool _check_remove_ability(size_t elements_cnt = SAFE_QUEUE_DEF_ELEM_CNT);
    inline bool _check_add_ability(size_t elements_cnt = SAFE_QUEUE_DEF_ELEM_CNT);
 
private:
    SQ_GUARD_CREATE(_push_guard);
    SQ_GUARD_CREATE(_pop_guard);
    size_t _front_i = 0x00, _end_i = 0x00, _counter = 0x00;
    T _buffer[SIZE];
};
 
 
/* ------------- Public methods -------------*/
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::push(const T * const data, size_t elements_cnt) {
    if (!SQ_GUARD_TRY_LOCK(_push_guard)) return false;
 
    /* Check _buffer available space */
    if (!elements_cnt || _check_add_ability(elements_cnt) == false) {
        SQ_GUARD_UNLOCK(_push_guard);
        return false;
    }
 
    for (size_t i = 0; i < elements_cnt; i++) {
        memcpy((uint8_t *)(_buffer + _end_i), (uint8_t *)(data + i), sizeof(T));
        _end_i = _get_next_index(_end_i);
        _counter++;
    }
 
    SQ_GUARD_UNLOCK(_push_guard);
    return true;
}
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::pop(size_t elements_cnt) {
    if (!SQ_GUARD_TRY_LOCK(_pop_guard)) return false;
 
    /* Maybe the _buffer available elements not enough */
    if (_check_remove_ability(elements_cnt) == false) { 
        SQ_GUARD_UNLOCK(_pop_guard);
        return false;
    }
 
    _front_i = _get_next_index(_front_i, elements_cnt);
    _counter -= elements_cnt;
 
    SQ_GUARD_UNLOCK(_pop_guard);
    return true;
}
 
template <typename T, size_t SIZE>
std::vector<T> SafeQueue<T, SIZE>::to_vector(size_t elements_cnt) {
    SQ_GUARD_LOCK(_pop_guard);
 
    /* Maybe the _buffer available elements not enough */
    if (!elements_cnt || elements_cnt > size()) {
        SQ_GUARD_UNLOCK(_pop_guard);
        return std::vector<T>();
    }
 
    size_t end_of_range_index = _get_next_index(_front_i, elements_cnt);
    uint8_t is_out_of_range = _front_i >= end_of_range_index;
 
    std::vector<T> converted (_buffer + _front_i, (is_out_of_range)? _buffer + SIZE : _buffer + end_of_range_index);
    if (is_out_of_range) converted.insert(converted.end(), _buffer, _buffer + end_of_range_index);
 
    SQ_GUARD_UNLOCK(_pop_guard);
    return converted;
}
 
template <typename T, size_t SIZE>
T* SafeQueue<T, SIZE>::front() {
    if (is_empty()) return NULL;
    return _buffer + _front_i;
}
 
template <typename T, size_t SIZE>
T* SafeQueue<T, SIZE>::back() {
    if (is_empty()) return NULL;
    return _buffer + _get_prev_index(_end_i);
}
 
template <typename T, size_t SIZE>
T* SafeQueue<T, SIZE>::at(size_t i) {
    if (is_empty() || i >= size()) return NULL;
    return _buffer + ((_front_i + i) % SIZE);
}
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::front(T* data) {
    if (!SQ_GUARD_TRY_LOCK(_pop_guard)) return false;
 
    if (!data || is_empty()) {
        SQ_GUARD_UNLOCK(_pop_guard);
        return false;
    }
    memcpy((uint8_t *)data, (uint8_t *)(_buffer + _front_i), sizeof(T));
 
    SQ_GUARD_UNLOCK(_pop_guard);
    return true;
}
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::back(T* data) {
    if (!SQ_GUARD_TRY_LOCK(_pop_guard)) return false;
 
    if (!data || is_empty()) {
        SQ_GUARD_UNLOCK(_pop_guard);
        return false;
    }
    memcpy((uint8_t *)data, (uint8_t *)(_buffer + _get_prev_index(_end_i)), sizeof(T));
 
    SQ_GUARD_UNLOCK(_pop_guard);
    return true;
}
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::at(size_t i, T* data) {
    if (!SQ_GUARD_TRY_LOCK(_pop_guard)) return false;
 
    if (!data || is_empty() || i >= size()) {
        SQ_GUARD_UNLOCK(_pop_guard);
        return false;
    }
    memcpy((uint8_t *)data, (uint8_t *)(_buffer + ((_front_i + i) % SIZE)), sizeof(T));
 
    SQ_GUARD_UNLOCK(_pop_guard);
    return true;
}
 
template <typename T, size_t SIZE>
void SafeQueue<T, SIZE>::clear() {
    pop(size());
}
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::is_empty() {
    return _counter == 0x00;
}
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::is_full() {
    return _counter == SIZE;
}
 
template <typename T, size_t SIZE>
size_t SafeQueue<T, SIZE>::size() {
    return _counter;
}
 
template <typename T, size_t SIZE>
size_t SafeQueue<T, SIZE>::available_space() {
    return SIZE - _counter;
}
 
template <typename T, size_t SIZE>
uint32_t SafeQueue<T, SIZE>::element_size() {
    return sizeof(T);
}
 
 
/* ------------- Private methods -------------*/
template <typename T, size_t SIZE>
size_t SafeQueue<T, SIZE>::_get_next_index(size_t base_index, size_t elements_cnt) {
    return (base_index + elements_cnt) % SIZE;
}
 
template <typename T, size_t SIZE>
size_t SafeQueue<T, SIZE>::_get_prev_index(size_t base_index, size_t elements_cnt) {
    return (base_index >= elements_cnt)? (base_index - elements_cnt) : (SIZE - (elements_cnt - base_index));
}
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::_check_remove_ability(size_t elements_cnt) {
    return size() >= elements_cnt;
}
 
template <typename T, size_t SIZE>
bool SafeQueue<T, SIZE>::_check_add_ability(size_t elements_cnt) {
    return (SIZE - size()) >= elements_cnt;
}
 
#endif /* SAFE_QUEUE_H_ */