PhxBitVector.h

Go to the documentation of this file.

#ifndef PHX_BITVECTOR_H
#define PHX_BITVECTOR_H

#include <Phx/PhxConfig.h>
#include <Phx/PhxTypes.h>
#include <fstream>

namespace Phx {

  class BitVector {
  public:
    typedef uint32_t Bits;
    typedef uint32_t Bytes;
    
    class InputStream;
    class OutputStream;
    class InputFile;
    class OutputFile;

    explicit BitVector(Bits bitCount = 16); // allocates buffer to fit bitCount bits
    explicit BitVector(const uint8_t* buffer, Bits bitCount); // incurs copy
    virtual ~BitVector();

    // copy / assignment
    BitVector(const BitVector&);
    const BitVector& operator=(const BitVector&);

    uint8_t* data() { return mData; }
    const uint8_t* data() const { return mData; }

    Bits bitCount() const { return mBitCount; }

    void bitCount(Bits bitCount);

    Bytes byteCount(void) const { return (bitCount() + 7) >> 3; }

    Bytes dataSize(void) const { return mDataSize; }

    void dataSize(Bytes dataSize);

    String stringField(Bits bitIndex) const;

    double doubleField(Bits bitIndex) const;

    float floatField(Bits bitIndex) const;

    uint64_t uint64Field(Bits bitIndex) const;

    uint32_t uint32Field(Bits bitIndex) const;

    uint16_t uint16Field(Bits bitIndex) const;

    uint8_t uint8Field(Bits bitIndex) const;

    int64_t int64Field(Bits bitIndex) const { return (int64_t)uint64Field(bitIndex); }

    int32_t int32Field(Bits bitIndex) const { return (int32_t)uint32Field(bitIndex); }

    int16_t int16Field(Bits bitIndex) const { return (int16_t)uint16Field(bitIndex); }

    int8_t int8Field(Bits bitIndex) const { return (int8_t)uint8Field(bitIndex); }

    //    uint32_t uintBitsField(Bits bitIndex, Bits numBits);

    //    int32_t intBitsField(Bits bitIndex, Bits numBits);

    bool boolField(Bits bitIndex) const;

    //BitVector bitVectorField(Bits bitIndex);

    void stringField(Bits bitIndex, const String& value);
    void doubleField(Bits bitIndex, double value);
    void floatField(Bits bitIndex, float value);
    void uint64Field(Bits bitIndex, uint64_t value);
    void uint32Field(Bits bitIndex, uint32_t value);
    void uint16Field(Bits bitIndex, uint16_t value);
    void uint8Field(Bits bitIndex, uint8_t value);
    void int64Field(Bits bitIndex, int64_t value) { uint64Field(bitIndex, (uint64_t)value); }
    void int32Field(Bits bitIndex, int32_t value) { uint32Field(bitIndex, (uint32_t)value); }
    void int16Field(Bits bitIndex, int16_t value) { uint16Field(bitIndex, (uint16_t)value); }
    void int8Field(Bits bitIndex, int8_t value) { uint8Field(bitIndex, (uint8_t)value); }
    //    void uintBitsField(Bits bitIndex, Bits numBits, uint32_t value);
    //    void intBitsField(Bits bitIndex, Bits numBits, int32_t value);
    void boolField(Bits bitIndex, bool value);

  private:
    void resizeBuffer(Bits bitCount);

    uint8_t*           mData;
    Bytes              mDataSize;

    Bits               mBitCount;
  };


  class BitVector::InputStream {
  public:
    InputStream(const BitVector* bitVector) : 
      mBitVector(bitVector), mReadIndex(0) {
      if (!mBitVector) {
        std::clog << "BitVector::InputStream:  NULL bit vector." << std::endl;
        throw RangeException();
      }
    }

    const BitVector& bitVector(void) const { return *mBitVector; }

    Bits readIndex(void) const { return mReadIndex; }

    void readIndex(Bits readIndex) { mReadIndex = readIndex; }
    
    bool endOfStream(void) { return mReadIndex >= mBitVector->bitCount(); }


    InputStream& operator>>(String& s) {
      s = mBitVector->stringField(mReadIndex);
      mReadIndex += sizeof(char) * 8 * (s.size()+1);
      return *this;
    }

    InputStream& operator>>(double& s) {
      s = mBitVector->doubleField(mReadIndex);
      mReadIndex += sizeof(double)*8;
      return *this;
    }

    InputStream& operator>>(float& s) {
      s = mBitVector->floatField(mReadIndex);
      mReadIndex += sizeof(float)*8;
      return *this;
    }

    InputStream& operator>>(uint64_t& s) {
      s = mBitVector->uint64Field(mReadIndex);
      mReadIndex += sizeof(uint64_t)*8;
      return *this;
    }

    InputStream& operator>>(uint32_t& s) {
      s = mBitVector->uint32Field(mReadIndex);
      mReadIndex += sizeof(uint32_t)*8;
      return *this;
    }

    InputStream& operator>>(uint16_t& s) {
      s = mBitVector->uint16Field(mReadIndex);
      mReadIndex += sizeof(uint16_t)*8;
      return *this;
    }

    InputStream& operator>>(uint8_t& s) {
      s = mBitVector->uint8Field(mReadIndex);
      mReadIndex += sizeof(uint8_t)*8;
      return *this;
    }

    InputStream& operator>>(int64_t& s) {
      s = mBitVector->int64Field(mReadIndex);
      mReadIndex += sizeof(int64_t)*8;
      return *this;
    }

    InputStream& operator>>(int32_t& s) {
      s = mBitVector->int32Field(mReadIndex);
      mReadIndex += sizeof(int32_t)*8;
      return *this;
    }

    InputStream& operator>>(int16_t& s) {
      s = mBitVector->int16Field(mReadIndex);
      mReadIndex += sizeof(int16_t)*8;
      return *this;
    }

    InputStream& operator>>(int8_t& s) {
      s = mBitVector->int8Field(mReadIndex);
      mReadIndex += sizeof(int8_t)*8;
      return *this;
    }

    InputStream& operator>>(bool& s) {
      s = mBitVector->boolField(mReadIndex);
      mReadIndex += 1;
      return *this;
    }

  private:
    const BitVector* mBitVector;
    Bits             mReadIndex;

    // no copy or assignment
    InputStream(InputStream& is);
    InputStream& operator=(InputStream&);
  };

  class BitVector::OutputStream {
  public:
    OutputStream(BitVector* bitVector) : 
      mBitVector(bitVector), mWriteIndex(0) {
      if (!mBitVector) {
        std::clog << "BitVector::OutputStream:  NULL bit vector." << std::endl;
        throw RangeException();
      }
    }
      
    BitVector& bitVector(void) { return *mBitVector; }

    Bits writeIndex(void) const { return mWriteIndex; }

    void writeIndex(Bits writeIndex) { mWriteIndex = writeIndex; }


    OutputStream& operator<<(const String& s) {
      mBitVector->stringField(mWriteIndex,s);
      mWriteIndex += sizeof(char) * 8 * (s.size()+1);
      return *this;
    }

    OutputStream& operator<<(double s) {
      mBitVector->doubleField(mWriteIndex,s);
      mWriteIndex += sizeof(double)*8;
      return *this;
    }

    OutputStream& operator<<(float s) {
      mBitVector->floatField(mWriteIndex,s);
      mWriteIndex += sizeof(float)*8;
      return *this;
    }

    OutputStream& operator<<(uint64_t s) {
      mBitVector->uint64Field(mWriteIndex,s);
      mWriteIndex += sizeof(uint64_t)*8;
      return *this;
    }

    OutputStream& operator<<(uint32_t s) {
      mBitVector->uint32Field(mWriteIndex,s);
      mWriteIndex += sizeof(uint32_t)*8;
      return *this;
    }

    OutputStream& operator<<(uint16_t s) {
      mBitVector->uint16Field(mWriteIndex,s);
      mWriteIndex += sizeof(uint16_t)*8;
      return *this;
    }

    OutputStream& operator<<(uint8_t s) {
      mBitVector->uint8Field(mWriteIndex,s);
      mWriteIndex += sizeof(uint8_t)*8;
      return *this;
    }

    OutputStream& operator<<(int64_t s) {
      mBitVector->int64Field(mWriteIndex,s);
      mWriteIndex += sizeof(int64_t)*8;
      return *this;
    }

    OutputStream& operator<<(int32_t s) {
      mBitVector->int32Field(mWriteIndex,s);
      mWriteIndex += sizeof(int32_t)*8;
      return *this;
    }

    OutputStream& operator<<(int16_t s) {
      mBitVector->int16Field(mWriteIndex,s);
      mWriteIndex += sizeof(int16_t)*8;
      return *this;
    }

    OutputStream& operator<<(int8_t s) {
      mBitVector->int8Field(mWriteIndex,s);
      mWriteIndex += sizeof(int8_t)*8;
      return *this;
    }

    OutputStream& operator<<(bool s) {
      mBitVector->boolField(mWriteIndex,s);
      mWriteIndex += 1;
      return *this;
    }

  private:
    BitVector*       mBitVector;
    Bits             mWriteIndex;

    // no copy or assignment
    OutputStream(OutputStream& is);
    OutputStream& operator=(OutputStream&);
  };

  class BitVector::InputFile {
  public:
    InputFile(const String& fileName);

    virtual ~InputFile();

    BitVector newBitVector(void);

    uint32_t bitVectorCount(void) const { return mBitVectorCount; }

    uint32_t bitVectorCountMax(void) const { return mBitVectorCountMax; }

  private:
    std::ifstream mFile;
    uint32_t      mBitVectorCount;
    uint32_t      mBitVectorCountMax;
  };

  class BitVector::OutputFile {
  public:

    OutputFile(const String& fileName);

    virtual ~OutputFile();

    void newBitVector(const BitVector& bitVector);

    uint32_t bitVectorCount(void) const { return mBitVectorCount; }

  private:
    std::ofstream mFile;
    uint32_t      mBitVectorCount;
  };

}; // namespace Phx

#endif /* PHX_BITVECTOR_H */

---