icarus::ns::util::details Namespace Reference

Classes
struct	BitObjHolder
	An object wrapping some data (copy), with a tag type. More...
struct	BinObjTag
	Tag object for BinObj. More...
struct	BinObj
	Holder for data to be presented in binary format (base 2). More...
struct	HexObjTag
struct	HexObj
	Holder for data to be presented in hexadecimal format (base 16). More...
struct	HexDumper
	Wrapper to have data printed as hexadecimal dump. More...
struct	ZeroPadder
	A wrapper padding the dump of its data with zeroes (or C). More...
struct	Blanks
	An object representing N characters of value C. More...

Functions
template<typename T >
constexpr T	fourMSBmask ()
	Returns a bit mask of type T with the four most significant bits set. More...
template<typename T >
void	printHex (std::ostream &out, T value)
	Prints a zero-padded integral value into out. More...
template<unsigned int N, char C = ' '>
std::ostream &	operator<< (std::ostream &out, Blanks< N, C >)
	Dumps N characters of value C to out stream. More...
template<typename T , unsigned int Bits>
std::ostream &	operator<< (std::ostream &out, BinObj< T, Bits > const &data)
	Dumps data bit by bit into out stream. More...
template<typename T >
std::ostream &	operator<< (std::ostream &out, HexObj< T > const &data)
	Dumps data nibble by nibble into out stream. More...
template<typename Atom >
std::ostream &	operator<< (std::ostream &out, HexDumper< Atom > const &data)
	Dumps data in a hexadecimal table. More...
template<typename T >
std::ostream &	operator<< (std::ostream &out, ZeroPadder< T > const &data)
	Dumps a value padding with 0 via ZeroPadder wrapper. More...

Function Documentation

template<typename T >

constexpr T icarus::ns::util::details::fourMSBmask

(

)

Returns a bit mask of type T with the four most significant bits set.

template<unsigned int N, char C = ' '>

std::ostream & icarus::ns::util::details::operator<<	(	std::ostream &	out,
		Blanks< N, C >
	)

Dumps N characters of value C to out stream.

Definition at line 390 of file BinaryDumpUtils.h.

{
  for (unsigned int i = 0U; i < N; ++i) out.put(C);
  return out;
} // icarus::ns::util::details::operator<< (icarus::ns::util::details::Blanks)

template<typename T , unsigned int Bits>

std::ostream & icarus::ns::util::details::operator<<	(	std::ostream &	out,
		BinObj< T, Bits > const &	data
	)

Dumps data bit by bit into out stream.

Parameters

out	output stream
data	data wrapper with information on how many bits to dump

Returns

the output stream out

Parameters of the dump are read from the data wrapper. The dump is in format (Bits) bbb bbbb bbbb ... (Bits is the number of bits, and b are bit values, 0 or 1, the first being the most significant bit).

Definition at line 400 of file BinaryDumpUtils.h.

{
  static_assert(std::is_integral_v<T>);
  static_assert(Bits > 0U);
  
  unsigned int bitsLeft = data.bits;
  T mask = T{ 1 } << (bitsLeft - 1);
  out << "(" << bitsLeft << ") ";
  while (mask) {
    out << ((data.data & mask)? '1': '0');
    mask >>= 1;
    if (--bitsLeft == 0) break;
    if ((bitsLeft & 0x03) == 0x00) out << ' ';
  } // while
  return out;
} // icarus::ns::util::details::operator<< (icarus::ns::util::details::BinObj)

template<typename T >

std::ostream & icarus::ns::util::details::operator<<	(	std::ostream &	out,
		HexObj< T > const &	data
	)

Dumps data nibble by nibble into out stream.

Parameters

out	output stream
data	data wrapper

Returns

the output stream out

The value in data is printed in hexadecimal format, including all its bits. The STL std::hex mode of a stream may be more convenient, but it's sticky:

using namespace icarus::ns::util;
std::cout << 36 << std::endl; // "36"
std::cout << details::HexObj{ 36 } << std::endl; // 00000024
std::cout << 36 << std::endl; // "36"
std::cout << std::hex << 36 << std::endl; // "24"
std::cout << 36 << std::endl; // "24" (std::hex is sticky)

Parameters of the dump are read from the data wrapper. The dump is in format (Bits) bbb bbbb bbbb ... (Bits is the number of bits, and b are bit values, 0 or 1, the first being the most significant bit).

Definition at line 421 of file BinaryDumpUtils.h.

  { printHex(out, data.data); return out; }

template<typename Atom >

std::ostream & icarus::ns::util::details::operator<<	(	std::ostream &	out,
		HexDumper< Atom > const &	data
	)

Dumps data in a hexadecimal table.

Parameters

out	output stream
data	data wrapper with information on how to dump it

Returns

the output stream out

Wrapped data is printed in a table: address of the first Atom of data, a separator |, a sequence of as many atom values as specified in data.columns, in hexadecimal format and zero-padded, and another separator |. If there are 6 or more columns, a larger space indentation is inserted between the two central columns. The table is written on a new line, and the line is ended after the table.

Definition at line 428 of file BinaryDumpUtils.h.

{
  
  static constexpr std::size_t AtomChars = sizeof(Atom) * 2;
  static constexpr Blanks<AtomChars> BlankAtom;
  
  auto const printAtoms = [&out]
    (Atom const* ptr, Atom const* const ptrend, std::ptrdiff_t columns)
    {
      /*
      FormatFlagsGuard const outGuard { out };
      out.setf(std::ios_base::hex, std::ios_base::basefield);
      out.unsetf(std::ios_base::showbase);
      out.fill('0');
      */
      Atom const* cend = ptr + columns;
      while (ptr != cend) {
        out << ' ';
        if (ptr < ptrend) {
          // out << std::setw(AtomChars) << *ptr;
          printHex(out, *ptr);
        }
        else              out << BlankAtom;
        ++ptr;
      } // while
      return ptr;
    };
  
  Atom const* ptr = data.data;
  Atom const* const ptrend = ptr + data.size;
  
  FormatFlagsGuard const outGuard { out };
  out.fill('0');
  
  auto const halfColumns = data.columns / 2;
  while (ptr < ptrend) {
    
    out << "\n" << std::setw(8) << ((void*) ptr) << " |";
    
    ptr = printAtoms(ptr, ptrend, data.columns - halfColumns);
    if (data.columns >= 6U) out << ' ';
    ptr = printAtoms(ptr, ptrend, halfColumns);
    out << " |";
    
  } // while
  
  out << '\n';
  
  return out;
} // operator<< (HexDumper)

template<typename T >

std::ostream & icarus::ns::util::details::operator<<	(	std::ostream &	out,
		ZeroPadder< T > const &	data
	)

Dumps a value padding with 0 via ZeroPadder wrapper.

Definition at line 483 of file BinaryDumpUtils.h.

{
  FormatFlagsGuard ffg { out };
  out.fill(data.pad);
  return out << std::setw(data.field) << data.data;
} // icarus::ns::util::details::operator<< (ZeroPadder)

template<typename T >

void icarus::ns::util::details::printHex	(	std::ostream &	out,
		T	value
	)

Prints a zero-padded integral value into out.

Definition at line 372 of file BinaryDumpUtils.h.

                                                           {
  static_assert(std::is_integral_v<T>, "Only integral types are supported.");
  
  // we actually store the null character at the end; it does not really matter
  constexpr const char HexChars[17U] = "0123456789ABCDEF";
  
  // print nibble by nibble, no spaces, starting from the most significant
  std::size_t nibblesLeft = sizeof(value) * 2U;
  while (nibblesLeft--) {
    std::size_t const digit = (value >> (nibblesLeft * 4U)) & 0xF;
    out << HexChars[digit];
  } // while
} // icarus::ns::util::details::printHex()