#include <AsciiImageWriter.hh>

Inheritance diagram for AsciiImageWriter:

Collaboration diagram for AsciiImageWriter:

Public Member Functions
	AsciiImageWriter (const BitVector &bits, int rowLength)

virtual	~AsciiImageWriter ()

virtual void	writeImage (std::ostream &stream) const

Public Member Functions inherited from BitImageWriter
virtual	~BitImageWriter ()

Protected Member Functions
const BitVector &	bits () const

int	rowLength () const

void	writeSequence (std::ostream &stream, int length, bool padEnd=false) const

void	writeHexSequence (std::ostream &stream, int length, bool padEnd=false) const

Private Attributes
const BitVector &	bits_
	The bits to be written. More...

int	rowLength_
	The length of a row in the output. More...

unsigned int	nextBitIndex_
	The index of the next bit to be written. More...

Detailed Description

Writes the bit image with ASCII 1's and 0's.

Definition at line 45 of file AsciiImageWriter.hh.

Constructor & Destructor Documentation

◆ AsciiImageWriter()

AsciiImageWriter::AsciiImageWriter	(	const BitVector &	bits,
		int	rowLength
	)

The constructor.

Parameters

bits	The bits to be written.
rowLength	The length of the row in the output stream.

Definition at line 55 of file AsciiImageWriter.cc.

                                                                        :
     bits_(bits), rowLength_(rowLength), nextBitIndex_(0) {
 }

◆ ~AsciiImageWriter()

AsciiImageWriter::~AsciiImageWriter ( )

virtual

The destructor.

Definition at line 63 of file AsciiImageWriter.cc.

63 {

64 }

Member Function Documentation

◆ bits()

const BitVector & AsciiImageWriter::bits ( ) const

protected

Returns the bit vector to be written by this writer.

Returns: The bit vector.

Definition at line 101 of file AsciiImageWriter.cc.

                              {
     return bits_;
 }

References bits_.

Referenced by MifImageWriter::writeHeader(), MifImageWriter::writeImage(), CoeImageWriter::writeImage(), ArrayImageWriter::writeImage(), AsciiProgramImageWriter::writeImage(), ArrayProgramImageWriter::writeImage(), and HexImageWriter::writeImage().

◆ rowLength()

int AsciiImageWriter::rowLength ( ) const

protected

Returns the row length.

Returns: The row length.

Definition at line 112 of file AsciiImageWriter.cc.

                                   {
     return rowLength_;
 }

References rowLength_.

Referenced by MifImageWriter::writeHeader(), VhdlImageWriter::writeHeader(), MifImageWriter::writeImage(), CoeImageWriter::writeImage(), ArrayImageWriter::writeImage(), and HexImageWriter::writeImage().

◆ writeHexSequence()

void AsciiImageWriter::writeHexSequence	(	std::ostream &	stream,
		int	length,
		bool	padEnd = `false`
	)		const

protected

Writes a sequence of bits in hex format to the given stream.

When this method is called sequentially, the first bit to be written is the next bit to the last bit written in the previous method call.

Parameters

stream	The output stream.
length	The length of the sequence to be written.

Exceptions

OutOfRange If the bit vector does not contain enough bits for the row.

Definition at line 160 of file AsciiImageWriter.cc.

                                                        {
     unsigned int lastIndex = nextBitIndex_ + length - 1;
  
     if (lastIndex >= bits_.size() && !padEnd) {
         const string procName = __func__;
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     const int nibbleCount = static_cast<int>(ceil(
         static_cast<double>(length) / 4.0));
  
     std::vector<bool> bitRow;
  
     // Copy bitstream for one row
     for (unsigned int i = nextBitIndex_; i <= lastIndex; ++i) {
         bitRow.push_back(bits_[i]);
     }
  
     // optionally extend bit stream
     int numPadBits = 4 * nibbleCount - length;
     if (numPadBits) {
         std::vector<bool> padBits(numPadBits, 0);
         bitRow.insert(bitRow.begin(), padBits.begin(), padBits.end());
     }
  
     // Generate a list of nibble
     std::vector<uint8_t> Nibble;
     for (auto it = bitRow.begin(); it < bitRow.end(); it += 4) {
         Nibble.push_back(std::accumulate(
             it, it + 4, 0,[] (int x, int y) {return (x << 1) + y;}));
     }
  
     // "print" hex stream
     for (auto ui8 = Nibble.begin(); ui8 < Nibble.end(); ++ui8) {
         stream << std::hex << (int) *ui8;
     }
  
     nextBitIndex_ += length;
 }

References __func__, bits_, and nextBitIndex_.

Referenced by HexImageWriter::writeImage().

◆ writeImage()

void AsciiImageWriter::writeImage ( std::ostream & stream ) const

virtual

Writes the bits to the given stream.

Parameters

stream The output stream.

Implements BitImageWriter.

Reimplemented in HexImageWriter, VhdlImageWriter, ArrayProgramImageWriter, VhdlProgramImageWriter, ArrayImageWriter, AsciiProgramImageWriter, CoeImageWriter, and MifImageWriter.

Definition at line 73 of file AsciiImageWriter.cc.

                                                      {
     int column = 0;
     for (BitVector::const_iterator iter = bits_.begin(); iter != bits_.end();
          iter++) {
         BitVector::const_iterator nextIter = iter;
         nextIter++;
         stream << *iter;
         column++;
         if (column == rowLength_ && nextIter != bits_.end()) {
             stream << '\n';
             column = 0;
         } else if (nextIter == bits_.end()) {
             // pad the remaining bits with zeroes if necessary
             while (column < rowLength_) {
                 stream << "0";
                 column++;
             }
         }
     }
 }

References bits_, and rowLength_.

Referenced by InstructionDictionary::generateDecompressor(), and MoveSlotDictionary::generateDictionaryVhdl().

◆ writeSequence()

void AsciiImageWriter::writeSequence	(	std::ostream &	stream,
		int	length,
		bool	padEnd = `false`
	)		const

protected

Writes a sequence of bits to the given stream.

When this method is called sequentially, the first bit to be written is the next bit to the last bit written in the previous method call.

Parameters

stream	The output stream.
length	The length of the sequence to be written.

Exceptions

OutOfRange If the bit vector does not contain enough bits for the row.

Definition at line 129 of file AsciiImageWriter.cc.

                                                        {
     unsigned int lastIndex = nextBitIndex_ + length - 1;
  
     if (lastIndex >= bits_.size() && !padEnd) {
         const string procName = "AsciiImageWriter::writeSequence";
         throw OutOfRange(__FILE__, __LINE__, procName);
     }
  
     for (unsigned int index = nextBitIndex_; index <= lastIndex; index++) {
         if (index < bits_.size()) {
             stream << bits_[index];
         } else {
             stream << "0";
         }
     }
     nextBitIndex_ = lastIndex + 1;
 }