Octane v1.01.20 - The Open Compression Toolkit for C++

http://octane.sourceforge.net/

bitio/bitwriter.hpp

Go to the documentation of this file.

//
// bitwriter  --  wrapper class for bit output
//
// Copyright (c) 2003 by Jørgen Ibsen / Jibz
// All Rights Reserved
//
// http://www.ibsensoftware.com/
//


#ifndef BITWRITER_HPP_INCLUDED
#define BITWRITER_HPP_INCLUDED

#include <string>
#include <cstddef>
#include <climits>

class bitwriter {

public:
    bitwriter() : num(0), current(0), mask(0x80) { ; }

    virtual ~bitwriter() { ; }

public:
    virtual bool error() const { return false; }

    void align_byte()
    {
        if (mask != 0x80)
        {
            ++num; write_next_byte(current);
            current = 0;
            mask = 0x80;
        }
    }

public:

    size_t bits_done() const { return 8*num + 8 - log2_tab[mask]; }
    size_t bytes_done() const { return num; }

    size_t tell_bit() const { return bits_done(); }

    size_t tell_byte() const { return bytes_done(); }


public:

    void put_bit(bool v)
    {
        if (v) current |= mask;
        if (!(mask >>= 1))
        {
            ++num; write_next_byte(current);
            current = 0;
            mask = 0x80;
        }
    }

    void put_byte(unsigned char v)
    {
        ++num;

        if (mask == 0x80) { write_next_byte(v); return; }

        unsigned char ml = log2_tab[mask];
        current |= v >> (8 - ml);
        write_next_byte(current);
        current = v << ml;
    }

    void put_word(unsigned short v)
    {
        put_byte((v >> 8) & 0x00ff);
        put_byte((v     ) & 0x00ff);
    }

    void put_dword(unsigned long v)
    {
        put_byte((unsigned char) ((v >> 24) & 0x00ff));
        put_byte((unsigned char) ((v >> 16) & 0x00ff));
        put_byte((unsigned char) ((v >> 8 ) & 0x00ff));
        put_byte((unsigned char) ((v      ) & 0x00ff));
    }

    void put_float(float v) { write((char*)&v, sizeof(float)); }

    void put_double(double v) { write((char*)&v, sizeof(double)); }

    void put_string(std::string &s)
    {
        size_t len = s.length();

        if ((len > 0x0000ffff) || (len == 0))
        {
            put_word(0);
            put_dword(len);
        } else {
            put_word(len);
        }

        write(s.c_str(), len);
    }

    void write(const char *buffer, size_t length)
    {
        for ( ; length; --length) put_byte(*buffer++);
    }


public:

    void put(bool v) { put_bit(v); }
    void put(char v) { put_byte(v); }
    void put(unsigned char v) { put_byte(v); }
    void put(short v) { put_word(v); }
    void put(unsigned short v) { put_word(v); }
#if UINT_MAX == 0xffff
    void put(int v) { put_word(v); }
    void put(unsigned int v) { put_word(v); }
#else
    void put(int v) { put_dword(v); }
    void put(unsigned int v) { put_dword(v); }
#endif
    void put(long v) { put_dword(v); }
    void put(unsigned long v) { put_dword(v); }

    void put(float v) { put_float(v); }
    void put(double v) { put_double(v); }
    void put(std::string &s) { put_string(s); }


protected:
    void finalize() { align_byte(); }

    virtual void write_next_byte(char c) = 0;

    size_t num;  

private:
    unsigned char current;  
    unsigned char mask;     

    static const unsigned char log2_tab[256];
};

#endif // BITWRITER_HPP_INCLUDED

 

Generated on 20 May 2004 by doxygen 1.3.3