DeviceBuffer.hxx

Go to the documentation of this file.

 
#ifndef _FREERTOS_DRIVERS_COMMON_DEVICE_BUFFER_HXX_
#define _FREERTOS_DRIVERS_COMMON_DEVICE_BUFFER_HXX_
 
#include <new>
#include <cstdint>
#include <unistd.h>
#include <stdlib.h>
 
#include "openmrn_features.h"
#include "utils/macros.h"
 
#ifdef OPENMRN_FEATURE_DEVTAB
#include "Devtab.hxx"
#endif // OPENMRN_FEATURE_DEVTAB
 
class DeviceBufferBase
{
public:
#ifdef OPENMRN_FEATURE_DEVTAB
    static void block_until_condition(File *file, bool read);
#endif // OPENMRN_FEATURE_DEVTAB
 
    void signal_condition()
    {
#ifdef OPENMRN_FEATURE_DEVTAB
        Device::select_wakeup(&selectInfo);
#endif // OPENMRN_FEATURE_DEVTAB
    }
 
    void signal_condition_from_isr()
    {
#ifdef OPENMRN_FEATURE_DEVTAB
        int woken = 0;
        Device::select_wakeup_from_isr(&selectInfo, &woken);
#endif // OPENMRN_FEATURE_DEVTAB
    }
 
    void flush()
    {
        count = 0;
        readIndex = 0;
        writeIndex = 0;
    }
 
    size_t pending()
    {
        return count;
    }
 
    size_t space()
    {
        return size - count;
    }
 
    void select_insert()
    {
#ifdef OPENMRN_FEATURE_DEVTAB
        return Device::select_insert(&selectInfo);
#endif // OPENMRN_FEATURE_DEVTAB
    }
 
    size_t consume(size_t items)
    {
        if (items > count)
        {
            items = count;
        }
        size_t consumed = items;
        count -= items;
        if ((readIndex + items) >= size)
        {
            items -= (size - readIndex);
            readIndex = 0;
        }
        readIndex += items;
 
        return consumed;
    }
 
    size_t advance(size_t items)
    {
        if (items > space())
        {
            items = space();
        }
        size_t added = items;
        count += items;
        if ((writeIndex + items) >= size)
        {
            items -= (size - writeIndex);
            writeIndex = 0;
        }
        writeIndex += items;
 
        return added;
    }
 
protected:
    DeviceBufferBase(size_t size, size_t level)
        : level(level)
        , size(size)
        , count(0)
        , readIndex(0)
        , writeIndex(0)
    {
    }
 
    ~DeviceBufferBase()
    {
    }
 
#ifdef OPENMRN_FEATURE_DEVTAB
    Device::SelectInfo selectInfo;
#endif // OPENMRN_FEATURE_DEVTAB
    
    uint16_t level;
    
    uint16_t size;
    
    uint16_t count;
    
    uint16_t readIndex;
    
    uint16_t writeIndex;
 
private:
    DISALLOW_COPY_AND_ASSIGN(DeviceBufferBase);
};
 
template <typename T> class DeviceBuffer : public DeviceBufferBase
{
public:
    static DeviceBuffer *create(size_t size, size_t level = 0)
    {
        HASSERT(size <= UINT16_MAX);
        HASSERT(level <= size);
        DeviceBuffer *device_buffer =
            (DeviceBuffer*)malloc(sizeof(DeviceBuffer) + (size * sizeof(T)));
        /* placement new allows for runtime ring buffer size */
        new (device_buffer) DeviceBuffer(size, level);
        
        return device_buffer;
    }
 
    typedef T member_type;
    
    static constexpr unsigned member_size()
    {
        return sizeof(T);
    }
 
    
    
    void destroy()
    {
        free(this);
    }
 
    size_t put(const T *buf, size_t items)
    {
        size_t last_count = count;
        
        while (items && (count < size))
        {
            data[writeIndex++] = *buf++;
            if (writeIndex == size)
            {
                writeIndex = 0;
            }
            ++count;
            --items;
        }
        
        return count - last_count;
    }
 
    size_t get(T *buf, size_t items)
    {
        size_t last_count = count;
        
        while (items && (count > 0))
        {
            *buf++ = data[readIndex++];            
            if (readIndex == size)
            {
                readIndex = 0;
            }
            --count;
            --items;
        }
        
        return last_count - count;
    }
 
    size_t data_read_pointer(T **buf)
    {
        size_t result = size - readIndex;
        if (count < result)
        {
            result = count;
        }
        *buf = data + readIndex;
        return result;
    }
 
    size_t data_write_pointer(T **buf)
    {
        size_t result = size - writeIndex;
        if (space() < result)
        {
            result = space();
        }
        *buf = data + writeIndex;
        return result;
    }
 
private:
    DeviceBuffer(size_t size, size_t level)
        : DeviceBufferBase(size, level)
    {
    }
 
    ~DeviceBuffer()
    {
    }
 
    DISALLOW_COPY_AND_ASSIGN(DeviceBuffer);
 
    T data[];
};
 
#endif /* _FREERTOS_DRIVERS_COMMON_DEVICE_BUFFER_HXX_ */