bstream.hh

#ifndef VTESTBED_BASE_BSTREAM_HH
#define VTESTBED_BASE_BSTREAM_HH

#include <cstddef>
#include <cstdint>
#include <limits>
#include <iterator>
#include <streambuf>
#include <type_traits>
#include <vtestbed/base/byte_order.hh>

#define VTB_PUT_GET(type) \
    inline bstream& operator<<(type rhs) { this->do_write(rhs); return *this; } \
    inline bstream& operator>>(type& rhs) { this->do_read(rhs); return *this; }

#define VTB_METHOD_TYPE(type, method) decltype(::std::declval<type>().method)

namespace vtb {

    namespace base {

        template <class T>
        struct has_begin_end: public std::false_type {};

        template <class T>
        struct has_reserve_emplace_back: public std::false_type {};

        class bstream {

        public:
            using char_type = char;
            using traits_type = std::char_traits<char>;
            using size_type = std::uint64_t;
            using streambuf = std::basic_streambuf<char_type,traits_type>;

        private:
            using size_limit = std::numeric_limits<size_type>;

        private:
            streambuf* _buffer = nullptr;

        public:

            inline explicit bstream(streambuf* buffer): _buffer(buffer) {}
            inline streambuf* rdbuf() { return this->_buffer; }
            inline const streambuf* rdbuf() const { return this->_buffer; }

            inline streambuf*
            rdbuf(streambuf* rhs) {
                streambuf* old = this->_buffer;
                this->_buffer = rhs;
                return old;
            }

            inline void sync() { this->_buffer->pubsync(); }
            inline void flush() { this->sync(); }

            inline void
            write(const char_type* s, size_type n) {
                this->_buffer->sputn(s, n);
            }

            inline void
            read(char_type* s, size_type n) {
                this->_buffer->sgetn(s, n);
            }

            bstream() = default;
            ~bstream() = default;
            bstream(bstream&&) = default;
            bstream& operator=(bstream&&) = default;
            bstream(const bstream&) = delete;
            bstream& operator=(const bstream&) = delete;

            template <class Ch, class Tr>
            typename std::enable_if<sizeof(Ch)==sizeof(char_type),bstream&>::type
            operator<<(const std::basic_string<Ch,Tr>& rhs) {
                if (rhs.size() > size_limit::max()) { this->throw_length(); }
                size_type size = static_cast<size_type>(rhs.size());
                this->do_write(size);
                this->write(reinterpret_cast<const char_type*>(rhs.data()), size);
                return *this;
            }

            template <class Ch, class Tr>
            typename std::enable_if<sizeof(Ch)==sizeof(char_type),bstream&>::type
            operator>>(std::basic_string<Ch,Tr>& rhs) {
                size_type size = 0;
                this->do_read(size);
                if (size > size_limit::max()) { this->throw_length(); }
                rhs.resize(size);
                this->read(reinterpret_cast<char_type*>(&rhs[0]), size);
                return *this;
            }

            template <class T>
            typename std::enable_if<has_begin_end<T>::value,bstream&>::type
            operator<<(const T& rhs) {
                size_type s = std::distance(rhs.begin(), rhs.end());
                if (s > size_limit::max()) { this->throw_length(); }
                size_type size = static_cast<size_type>(s);
                this->do_write(size);
                for (const auto& value : rhs) { *this << value; }
                return *this;
            }

            template <class T>
            typename std::enable_if<has_reserve_emplace_back<T>::value,bstream&>::type
            operator>>(T& rhs) {
                size_type size = 0;
                this->do_read(size);
                if (size > size_limit::max()) { this->throw_length(); }
                rhs.reserve(size);
                for (size_type i=0; i<size; ++i) {
                    rhs.emplace_back();
                    *this >> rhs.back();
                }
                return *this;
            }

            inline bstream&
            operator<<(float rhs) {
                this->do_write(static_cast<double>(rhs));
                return *this;
            }

            inline bstream&
            operator>>(float& rhs) {
                double tmp{};
                this->do_read(tmp);
                rhs = static_cast<float>(tmp);
                return *this;
            }

            VTB_PUT_GET(std::uint8_t);
            VTB_PUT_GET(std::uint16_t);
            VTB_PUT_GET(std::uint32_t);
            VTB_PUT_GET(std::uint64_t);
            VTB_PUT_GET(std::int8_t);
            VTB_PUT_GET(std::int16_t);
            VTB_PUT_GET(std::int32_t);
            VTB_PUT_GET(std::int64_t);
            VTB_PUT_GET(char);
            VTB_PUT_GET(double);

        private:

            template <class T>
            inline void
            do_write(T value) {
                static_assert(std::is_integral<T>::value ||
                    (std::is_floating_point<T>::value &&
                     std::numeric_limits<T>::is_iec559), "bad type");
                bytes<T> u;
                u.orig = value;
                u.swap();
                this->write(u.bytes, sizeof(T)*sizeof(char_type));
            }

            template <class T>
            inline void
            do_read(T& value) {
                static_assert(std::is_integral<T>::value ||
                    (std::is_floating_point<T>::value &&
                     std::numeric_limits<T>::is_iec559), "bad type");
                bytes<T> u;
                this->read(u.bytes, sizeof(T)*sizeof(char_type));
                u.swap();
                value = u.orig;
            }

            inline void
            throw_length() {
                throw std::length_error("bstream");
            }

        };

    }

    namespace core {

        typedef ::vtb::base::bstream bstream;

    }

}

#undef VTB_PUT_GET
#undef VTB_METHOD_TYPE

#endif // vim:filetype=cpp