fileringbuffer.h

Go to the documentation of this file.

 
#ifndef DISK_RING_BUFFER_H
#define DISK_RING_BUFFER_H
 
#include <a_util/memory.h>
#include <cstring>
 
namespace utils5ext
{

template <typename ADDITIONAL_DATA = uint8_t, uint8_t alignment = 1, uint8_t alignment_fill = 0x00>
class FileRingBuffer
{
    public:
        struct Item
        {
            Item(): file_pos(-1), size(0) {}
            FilePos file_pos; 
            size_t size; 
            ADDITIONAL_DATA additional; 
        };

        class DropCallback
        {
            public:
                virtual void onDrop(const Item& dropped_item, const Item& next_item) = 0;
        };

        struct ItemPiece
        {
            const void* data; 
            size_t data_size; 
        };

        typedef std::deque<Item> Items;
        typedef typename Items::const_iterator const_iterator;
 
    private:
        Items                        _items;
        File*                        _file;
        FilePos                      _start_offset;
        FilePos                      _current_pos;
        FileSize                     _current_size;
        FileSize                     _max_size;
        bool                         _bookkeeping;
        DropCallback*                _callback;
        a_util::memory::MemoryBuffer _alignment_buffer;
        Item                         _rear_item;
 
    public:
        FileRingBuffer(File* file, FilePos start_offset = 0,
            FileSize max_size = 0, DropCallback* drop_callback = nullptr) :
            _file(file),
            _start_offset(start_offset),
            _current_size(0),
            _max_size(max_size),
            _bookkeeping(true),
            _callback(drop_callback)
        {
            file->setFilePos(start_offset, File::fp_begin);
            _current_pos = start_offset;
 
#ifdef _WIN32
    __pragma(warning(push))
    __pragma(warning(disable:4127))
#endif
                if (alignment > 1)
                {
                    _alignment_buffer.allocate(alignment - 1);
                    std::memset(_alignment_buffer.getPtr(), alignment_fill, _alignment_buffer.getSize());
                }
#ifdef _WIN32
    __pragma(warning(pop))
#endif
                fillForAlignment();
        }

        const FileSize& getCurrentSize()
        {
            return _current_size;
        }

        void startWrappingAround()
        {
            if (!_bookkeeping)
            {
                throw std::runtime_error("history already started wrapping around");
            }
 
            _max_size = _current_size;
        }

        void startAppending(Item* rear_data_item = nullptr, Item* last_data_item = nullptr)
        {
            if (!_bookkeeping)
            {
                throw std::runtime_error("already appending");
            }
 
            _max_size = 0;
            _file->setFilePos(0, File::fp_end);
            _current_pos = _file->getFilePos();
            _bookkeeping = false;
 
            if (_rear_item.file_pos == -1 && !_items.empty())
            {
                // we never wrapped around.
                _rear_item = _items.back();
            }
 
            if (rear_data_item)
            {
                *rear_data_item = _rear_item;
            }
 
            if (last_data_item)
            {
                if (!_items.empty())
                {
                    *last_data_item = _items.back();
                }
                else
                {
                    *last_data_item = Item();
                }
            }
        }

        void appendItem(const void* data, size_t data_size,
                        const ADDITIONAL_DATA& additional, FilePos* file_pos = nullptr)
        {
            ItemPiece item;
            item.data = data;
            item.dataSize = data_size;
            appendItem(&item, 1, additional, file_pos);
        }

        void appendItem(const ItemPiece* pieces, size_t count,
                        const ADDITIONAL_DATA& additional, FilePos* file_pos = nullptr)
        {
            size_t data_size = 0;
            for (size_t piece = 0; piece < count; ++piece)
            {
                data_size += pieces[piece].data_size;
            }
 
            if (_max_size && !_items.empty())
            {
                if (_current_pos + static_cast<FileSize>(data_size) > _max_size)
                {
                    // in this case we need to wrap around
                    _file->truncate(_current_pos);
                    _current_size = _current_pos;
 
                    _rear_item = _items.back();
 
                    //we need remove all items following this postion
                    while (_items.front().file_pos >= _current_pos)
                    {
                        popFront();
                    }
 
                    _current_pos = _items.front().file_pos; // this should be equal to the data offset
                    _file->setFilePos(_current_pos, File::fp_begin);
                }
            }
 
            if (file_pos)
            {
                *file_pos = _current_pos;
            }
 
            FilePos write_pos = _current_pos;
 
            for (size_t piece = 0; piece < count; ++piece)
            {
                _file->writeAll(pieces[piece].data, static_cast<int>(pieces[piece].data_size));
            }
 
            _current_pos += data_size;
 
            fillForAlignment();
 
            if (_current_pos > _current_size)
            {
                _current_size = _current_pos;
            }
 
            if (_bookkeeping)
            {
                Item item;
                item.file_pos = write_pos;
                item.size = data_size;
                item.additional = additional;
 
                _items.push_back(item);
 
                FilePos start = item.file_pos;
                FilePos end = _current_pos;
 
                while (_items.size() > 1 &&
                    _items.front().file_pos >= start &&
                    _items.front().file_pos < end)
                {
                    popFront();
                }
 
                if (_rear_item.file_pos != -1)
                {
                    // we did wrap around at least once
                    // check if this item did overwrite the current rear item
                    if (_rear_item.file_pos < end)
                    {
                        // it has been overwritten by the current one
                        // and was alread removed from the queue in the while loop above
                        // so the current item is the new rear item.
                        _rear_item = _items.back();
                        // make sure that the file ends after the current item
                        _file->truncate(_current_pos);
                        _current_size = _current_pos;
                    }
                }
            }
        }

        const_iterator begin() const
        {
            return _items.begin();
        }

        const_iterator end() const
        {
            return _items.end();
        }
 
    protected:
        void fillForAlignment()
        {
            FilePos mod = _current_pos % alignment;
            if (mod)
            {
                FilePos fill = alignment - mod;
                _file->writeAll(_alignment_buffer.getPtr(),
                                  static_cast<size_t>(fill));
                _current_pos += fill;
            }
        }

        void popFront()
        {
            if (_callback)
            {
                static Item dummy;
 
                Item& item = _items.front();
                Item* next = &dummy;
                if (_items.size() > 1)
                {
                    next = &_items[1];
                }
                _callback->onDrop(item, *next);
            }
            _items.pop_front();
        }
};
 
}
 
#endif