src/ChunkedBuffer.hh

/*
 * Copyright Staffan Gimåker 2006-2008.
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 */

#ifndef __PEEKABOT_CHUNKED_BUFFER_HH
#define __PEEKABOT_CHUNKED_BUFFER_HH


#include "Types.hh"


namespace peekabot
{


    class ChunkedBuffer
    {
        class Chunk
        {
            const size_t m_capacity;
            size_t m_wptr;
            size_t m_rptr;
            uint8_t *m_data;

        public:

            Chunk(size_t _size) throw();

            ~Chunk() throw();

            inline size_t write(const void *buf, size_t n) throw()
            {
                size_t written = std::min(m_capacity-m_wptr, n);
                
                memcpy((uint8_t *)m_data+m_wptr, buf, written);
                m_wptr += written;
                
                return written;
            }

            inline size_t overwrite(const void *buf, size_t n, size_t pos) throw()
            {
                size_t written = std::min(n, m_wptr-pos);
                
                memcpy((uint8_t *)m_data+pos, buf, written);
                
                return written;
            }


            inline size_t peek(void *buf, size_t n) throw()
            {
                size_t read = std::min(get_available_count(), n);
                
                memcpy(buf, (uint8_t *)m_data+m_rptr, read);
                
                return read;
            }

            inline size_t read(void *buf, size_t n) throw()
            {
                size_t read = std::min(get_available_count(), n);
                
                memcpy(buf, (uint8_t *)m_data+m_rptr, read);
                m_rptr += read;
                
                return read;
            }

            inline size_t discard(size_t n) throw()
            {
                size_t read = std::min(get_available_count(), n);
                
                m_rptr += read;
                
                return read;
            }

            inline size_t get_available_count() const throw()
            {
                return m_wptr-m_rptr;
            }

            inline size_t get_remaining_capacity() const throw()
            {
                return m_capacity-m_wptr;
            }


            inline size_t get_bytes_read() const throw()
            {
                return m_rptr;
            }


            inline size_t get_bytes_written() const throw()
            {
                return m_wptr;
            }

            void clear() throw();
        };




        struct Node
        {
            Node(Node *next, Node *prev, Chunk *chunk) throw();

            ~Node() throw();

            Node  *m_next;
            Node  *m_prev;
            Chunk *m_chunk;
        };


        const size_t m_chunk_size;


        size_t m_size;

        size_t m_chunk_count;

        Node *m_read_node;

        Node *m_write_node;


    private:
        void grow_on_demand() throw();

        void shrink_on_demand() throw();




    public:
        ChunkedBuffer(size_t chunk_size) throw();

        ChunkedBuffer(const ChunkedBuffer &buf) throw();
        
        ~ChunkedBuffer() throw();

        size_t read(void *buf, size_t max_bytes) throw();

        size_t discard(size_t max_bytes) throw();

        uint8_t read_byte() throw();

        size_t peek(void *buf, size_t max_bytes) const throw();

        bool peek(uint8_t &x) const throw();

        void write(const void *buf, size_t n) throw();

        void write_byte(uint8_t x) throw();

        
        bool overwrite(const void *buf, size_t n, size_t pos) throw();

        void clear() throw();

        size_t get_size() const throw();

        bool is_empty() const throw();

        size_t get_chunk_size() const throw();



        class StreambufAdapter : public std::streambuf
        {
            ChunkedBuffer &m_buf;
        public:
            StreambufAdapter(ChunkedBuffer &buf);
            
        protected:
            virtual int_type overflow(int_type c);

            virtual int_type underflow();

            virtual int_type uflow();

            virtual std::streamsize xsputn(const char *s, std::streamsize n);

            virtual std::streamsize xsgetn(char *s, std::streamsize n);
        };
    };

}


#endif // __PEEKABOT_CHUNKED_BUFFER_HH