bitStream.hpp

Go to the documentation of this file.

// Copyright (c) 2013 Michael D. Adams
// All rights reserved.

// __START_OF_LICENSE__
// 
// Copyright (c) 2015 Michael D. Adams
// All rights reserved.
// 
// This file is part of the Signal Processing Library (SPL).
// 
// This program 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,
// or (at your option) any later version.
// 
// This program 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 this program; see the file LICENSE.  If not,
// see <http://www.gnu.org/licenses/>.
// 
// __END_OF_LICENSE__

#ifndef SPL_bitStream_hpp
#define SPL_bitStream_hpp

// Header files

#include <SPL/config.hpp>
#include <cassert>
#include <iostream>

namespace SPL {

// Bit stream class

class BitStream
{

public:

        typedef unsigned IoState;

        /*
         * The I/O state bits.
         */
        static const IoState eofBit = 1;
        static const IoState limitBit = 2;
        static const IoState badBit = 4;
        static const IoState allIoBits = eofBit | limitBit | badBit;

        typedef unsigned long long Size;

        typedef long long Offset;

        bool isOkay() const;

        bool isEof() const;

        bool isLimit() const;

        IoState getIoState() const;

        void setIoState(IoState state);

        void setIoStateBits(IoState state);

        void clearIoStateBits(IoState state = allIoBits);

protected:

        // Default constructor
        BitStream() : ioState_(0) {}

        // I/O state of bit stream (a bitmask).
        IoState ioState_;

private:

        // The copy constructor is declared but not defined in order to
        // prevent copying.
        BitStream(const BitStream&);

        // The copy assignment operator is declared but not defined in order to
        // prevent copy assignment.
        BitStream& operator=(const BitStream&);

};

inline bool BitStream::isOkay() const
{
        return !(ioState_ & (badBit | limitBit));
}

inline bool BitStream::isEof() const
{
        return ioState_ & eofBit;
}

inline bool BitStream::isLimit() const
{
        return ioState_ & limitBit;
}

inline void BitStream::setIoState(BitStream::IoState state)
{
        assert(!(state & (~allIoBits)));
        ioState_ = state;
}

inline BitStream::IoState BitStream::getIoState() const
{
        return ioState_;
}

inline void BitStream::clearIoStateBits(BitStream::IoState mask)
{
        assert(!(mask & (~allIoBits)));
        ioState_ &= ~mask;
}

inline void BitStream::setIoStateBits(BitStream::IoState mask)
{
        assert(!(mask & (~allIoBits)));
        ioState_ |= mask;
}

// Input Bit Stream Class

class InputBitStream : public BitStream
{

public:

        // Constructors and destructor

        InputBitStream();

        InputBitStream(std::istream& in);

        ~InputBitStream();

        // Set and get various state

        std::istream* getInput() const;

        void setInput(std::istream* in);

        Offset getReadLimit() const;

        void setReadLimit(Offset readLimit);

        Size getReadCount() const;

        void clearReadCount();

        // Input

        long getBits(int numBits);

        // Alignment

        void align();

        // Debugging

        void dump(std::ostream& out) const;

private:

        // The copy constructor is declared but not defined in order to
        // prevent copying.
        InputBitStream(const InputBitStream&);

        // The copy assignment operator is declared but not defined in order to
        // prevent copy assignment.
        InputBitStream& operator=(const InputBitStream&);
        
        bool fillBuf();

        // The underlying character stream.
        std::istream* in_;

        // The input buffer.
        unsigned char buf_;

        // The number of bits remaining before the buffer is empty.
        int count_;

        // The maximum number of bits that may still be read from the bit
        // stream.  If this quantity is negative, there is no limit.
        Offset readLimit_;

        // The number of bits read from the bit stream so far.
        Size readCount_;

};

inline void InputBitStream::clearReadCount()
{
        readCount_ = 0;
}

inline InputBitStream::Size InputBitStream::getReadCount() const
{
        return readCount_;
}

inline void InputBitStream::setReadLimit(InputBitStream::Offset readLimit)
{
        readLimit_ = readLimit;
}

inline InputBitStream::Offset InputBitStream::getReadLimit() const
{
        return readLimit_;
}

// Output Bit Stream Class

class OutputBitStream : public BitStream
{

public:

        // Constructors and destructor

        OutputBitStream();

        OutputBitStream(std::ostream& out);

        ~OutputBitStream();

        // Get and set various bit stream state.

        std::ostream* getOutput() const;

        void setOutput(std::ostream* out);

        void clearWriteCount();

        Size getWriteCount() const;

        void setWriteLimit(Offset writeLimit);

        Offset getWriteLimit() const;

        // Output

        int putBits(long data, int numBits);

        // Alignment and flushing

        void align();

        void flush();

        // Debugging

        void dump(std::ostream& out) const;

private:

        // The copy constructor is declared but not defined in order to
        // prevent copying.
        OutputBitStream(const OutputBitStream&);

        // The copy assignment operator is declared but not defined in order to
        // prevent copy assignment.
        OutputBitStream& operator=(const OutputBitStream&);
        
        bool flushBuf();

        // The underlying character stream.
        std::ostream* out_;

        // The output buffer.
        unsigned char buf_;

        // The number of bits remaining before the buffer is full.
        int count_;

        // The number of bits written to the underlying stream.
        Size writeCount_;

        // The maximum number of bits that may still be written to the underlying
        // stream.  If this quantity is negative, there is no limit.
        Offset writeLimit_;

};

inline OutputBitStream::Size OutputBitStream::getWriteCount() const
{
        return writeCount_;
}

inline void OutputBitStream::clearWriteCount()
{
        writeCount_ = 0;
}

inline OutputBitStream::Offset OutputBitStream::getWriteLimit() const
{
        return writeLimit_;
}

inline void OutputBitStream::setWriteLimit(OutputBitStream::Offset writeLimit)
{
        writeLimit_ = writeLimit;
}

//

}

#endif