bit_stream.hpp

Go to the documentation of this file.

// Copyright (C) 2012 iwg molw5
// For conditions of distribution and use, see copyright notice in COPYING

#pragma once

#include <cstdint>
#include <cassert>
#include <type_traits>
#include <climits>

#include <framework/common/common_macros.hpp>
#include <framework/common/variadic_switch_return.hpp>
#include <framework/common/endian.hpp>

namespace framework
{
    namespace serializable
    {
        template <typename Stream, typename Block>
        class bit_stream : private std::reference_wrapper <Stream>
        {
            private:
                using buffer_type = typename std::make_unsigned <type_extractor <Block>>::type;
                enum{ block_bytes = sizeof(buffer_type) };
                enum{ block_bits = CHAR_BIT*block_bytes };
                enum{ block_mask = static_cast <buffer_type> (~static_cast <buffer_type> (0)) };
                enum{ byte_mask = static_cast <unsigned char> (~static_cast <unsigned char> (0)) };
                using case_list = make_values <std::size_t, block_bits + 1>;

                template <std::size_t N>
                struct read_handler_fixed;

                template <std::size_t N, std::size_t Buffer, typename Enabler = void>
                struct read_bits_impl;

                template <std::size_t>
                struct write_handler_fixed;

                template <std::size_t N, std::size_t Buffer, typename Enabler = void>
                struct write_bits_impl;
                
                struct read_handler_dynamic;
                struct write_handler_dynamic;

            public:
                bit_stream (Stream& s)
                    : std::reference_wrapper <Stream> (s)
                {
                }

                template <std::size_t N>
                bool read (char* s)
                {
                    for (std::size_t i=0; i < N; ++i, ++s)
                        if (!read_bits <8> (*s))
                            return false;

                    return true;
                }

                bool read (char* s, std::size_t n)
                {
                    for (std::size_t i=0; i < n; ++i, ++s)
                        if (!read_bits <8> (*s))
                            return false;

                    return true;
                }

                template <std::size_t N>
                bool write (char const* s)
                {
                    for (std::size_t i=0; i < N; ++i, ++s)
                        if (!write_bits <8> (*s))
                            return false;

                    return true;
                }

                bool write (char const* s, std::size_t n)
                {
                    for (std::size_t i=0; i < n; ++i, ++s)
                        if (!write_bits <8> (*s))
                            return false;

                    return true;
                }

                template <std::size_t N, typename T>
                bool read_bits (T& t)
                {
                    auto& value = reinterpret_cast <typename std::make_unsigned <T>::type&> (t);
                    return variadic_switch_return <case_list> (read_handler_fixed <N> {}, p_iInputBlockBits, *this, value);
                }

                template <typename T>
                bool read_bits (T& t, std::size_t n)
                {
                    auto& value = reinterpret_cast <typename std::make_unsigned <T>::type&> (t);
                    return variadic_switch_return <case_list> (read_handler_dynamic{}, p_iInputBlockBits, *this, value, n);
                }

                template <std::size_t N, typename T>
                bool write_bits (T const& t)
                {
                    auto const& value = reinterpret_cast <typename std::make_unsigned <T>::type const&> (t);
                    return variadic_switch_return <case_list> (write_handler_fixed <N> (), p_iOutputBlockBits, *this, value);
                }

                template <typename T>
                bool write_bits (T const& t, std::size_t n)
                {
                    auto const& value = reinterpret_cast <typename std::make_unsigned <T>::type const&> (t);
                    return variadic_switch_return <case_list> (write_handler_dynamic{}, p_iOutputBlockBits, *this, value, n);
                }

                bool flush ()
                {
                    if (p_iOutputBlockBits < block_bits)
                    {
                        auto const value = static_cast <type_extractor <Block>> (p_iOutputBlock);
                        if (!dispatch_write <Block> (value, this->get()))
                            return false;

                        p_iOutputBlock = 0;
                        p_iOutputBlockBits = block_bits;
                    }

                    return true;
                }

            private:
                buffer_type p_iInputBlock {0};
                std::size_t p_iInputBlockBits {0};

                buffer_type p_iOutputBlock {0};
                std::size_t p_iOutputBlockBits {block_bits};
        };
    }
}

#include <framework/serializable/streams/bit_stream.inl>