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 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);

    Bits nextIndex(void) const { return mNextIndex; }

    String stringField(Bits bitIndex);

    double doubleField(Bits bitIndex);

    float floatField(Bits bitIndex);

    uint64_t uint64Field(Bits bitIndex);

    uint32_t uint32Field(Bits bitIndex);

    uint16_t uint16Field(Bits bitIndex);

    uint8_t uint8Field(Bits bitIndex);

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

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

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

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

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

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

    bool boolField(Bits bitIndex);

    //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;
    Bits               mNextIndex;
  };

  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 */

---