root/tls/ringbuf.hh

/*  This file is part of Alue, the multiprotocol Internet discussion daemon

    Copyright © 2010 Antti-Juhani Kaijanaho

    Alue is free software: you can redistribute it and/or modify it
    under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Alue is distributed in the hope that it will be useful, but
    WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Alue.  If not, see <http://www.gnu.org/licenses/>.

 */

#ifndef GUARD_TLS_RINGBUF_HH
#define GUARD_TLS_RINGBUF_HH

#include <boost/asio.hpp>
#include <boost/noncopyable.hpp>
#include <cstdlib>
#include <cstring>
#include <stdexcept>

namespace tls
{
        class ringbuf : private boost::noncopyable
        {
                size_t rd, wr, n, N;
                unsigned char *arr;

                const unsigned char *rda1() const { return arr + rd; }
                unsigned char *wra1()             { return arr + wr; }
                const unsigned char *rda2() const { return arr + (rd < wr ? rd : 0); }
                unsigned char *wra2()             { return arr + (wr < rd ? wr : 0); }
                // rds1() and rds2() give meaningless answers if n == 0
                // wrs1() and wrs2() give meaningless answers if n == N
                size_t rds1() const { return rd >= wr ? N - rd : 0; }
                size_t wrs1() const { return wr >= rd ? N - wr : 0; }
                size_t rds2() const { return rd < wr ? wr - rd : wr; }
                size_t wrs2() const { return wr < rd ? rd - wr : rd; }
        public:
                explicit ringbuf(size_t N)
                        : rd(0)
                        , wr(0)
                        , n(0)
                        , N(N)
                        , arr((unsigned char*)std::malloc(N)) {
                        if (arr == 0) throw std::bad_alloc();
                }
                ~ringbuf() { std::free(arr); }

                bool empty() const { return n == 0; }
                bool full() const { return n == N; }
                
                std::vector<boost::asio::mutable_buffer> write_area();
                std::vector<boost::asio::const_buffer> read_area() const;
                void read(size_t k) {
                        BOOST_ASSERT(k <= n);
                        n -= k;
                        rd += k;
                        rd %= N;
                        BOOST_ASSERT((rd == wr) == (n == 0 || n == N));
                        BOOST_ASSERT(n <= N);
                }
                void written(size_t k) {
                        BOOST_ASSERT(n + k <= N);
                        n += k;
                        wr += k;
                        wr %= N;
                        BOOST_ASSERT((rd == wr) == (n == 0 || n == N));
                        BOOST_ASSERT(n <= N);
                }
                size_t get(unsigned char *out, size_t k);
                size_t put(const unsigned char *in, size_t k);
        };
}

#endif /* GUARD_TLS_RINGBUF_HH */