PStack  2.0
Stack trace printer for MSVC and GCC binaries
Namespaces
psystem::format Namespace Reference

Formatting facilities for std::ostream output. More...

Namespaces

 internal
 Internal structures used for the psystem::format namespace.
 

Bitmask Pretty-print

template<typename T >
internal::mask_ostream_output_tag< T > mask (T const m) noexcept
 Mark output stream data to be formatted as a bit-mask. More...
 

Hexadecimal Pretty-print

template<typename T >
internal::hex_ostream_output_tag< T > hex (T const v) noexcept
 Mark output stream data to be formatted as a hexadecimal number. More...
 

Pointer Pretty-print

internal::ptr_ostream_output_tag ptr (void const *p) noexcept
 Mark output stream data to be formatted as a memory address. More...
 
internal::ptr_ostream_output_tag ptr (psystem::address_t const p) noexcept
 Mark output stream data to be formatted as a memory address. More...
 
template<typename R , typename... Args>
internal::ptr_ostream_output_tag ptr (R(*p)(Args...)) noexcept
 Mark a function pointer to be formatted to an output stream as a memory address. More...
 

Boolean Value Pretty-print

internal::swtch_ostream_output_tag swtch (bool const s) noexcept
 Mark output stream data to be formatted as an on/off switch. More...
 

Detailed Description

Formatting facilities for std::ostream output.

These are tags that have little or no run-time cost, and will format data as it sends it directly to the output stream. An example program:

#include <iostream>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <psystem/framework/iomanip.hpp>
using psystem::framework::mask;
int main()
{
stat file_info = { 0 };
if (0 == stat("/", &file_info))
{
std::cout << "File permissions are: " << mask(file_info.st_mode) << '\n';
}
return 0;
}

... which outputs: 

File permissions are: (0x000001ED)
Author
Matt Bisson
Date
18 August, 2014
Since
PSystem 2.0
Version
PSystem 2.0

Function Documentation

template<typename T >
internal::hex_ostream_output_tag<T> psystem::format::hex ( T const  v)
inlinenoexcept

Mark output stream data to be formatted as a hexadecimal number.

This will be sent to an std::ostream instance using operator<< as an hexidecimal number. For example:

int32_t const number = 32780;
std::cout << "The number is: " << hex(number) << '\n';

...produces the output:

The number is: 0x800C
Template Parameters
TThe parameter type must be an intergral type.
Parameters
[in]vThe numerical data to format.
Returns
Internal implementation may vary.
template<typename T >
internal::mask_ostream_output_tag<T> psystem::format::mask ( T const  m)
inlinenoexcept

Mark output stream data to be formatted as a bit-mask.

Depending on the size of the input data, this will be sent to an std::ostream instance using operator<< as a zero-padded hexidecimal number. It will be surrounded by parentheses. For example:

short int const flags = 0x13;
std::cout << "The flags are: " << mask(flags) << '\n';

...produces the output:

The flags are: (0x0013)
Template Parameters
TThe parameter type must be an intergral type.
Parameters
[in]mThe bit-mask to format.
Returns
Internal implementation may vary.
internal::ptr_ostream_output_tag psystem::format::ptr ( void const *  p)
inlinenoexcept

Mark output stream data to be formatted as a memory address.

This function only applies to data that can be converted implicitly to a void* data-type. The output will be zero-padded to the length of addresses on the target architecture. For example:

std::string const test = "test!";
std::cout << "The address is: " << ptr(test.c_str()) << '\n';

...produces output like:

The address is: 0x0000007FF018E924
Parameters
[in]pThe pointer / address to format.
Returns
Internal implementation may vary.
internal::ptr_ostream_output_tag psystem::format::ptr ( psystem::address_t const  p)
inlinenoexcept

Mark output stream data to be formatted as a memory address.

This function only applies to input that can be converted to the psystem::address_t type. The output will be zero-padded to the length of addresses on the target architecture. For example:

psystem::address_t const addr = get_some_address();
std::cout << "The address is: " << ptr(addr) << '\n';

...produces output like:

The address is: 0x0000001FE0384BB4
Parameters
[in]pThe address to format.
Returns
Internal implementation may vary.
template<typename R , typename... Args>
internal::ptr_ostream_output_tag psystem::format::ptr ( R(*)(Args...)  p)
inlinenoexcept

Mark a function pointer to be formatted to an output stream as a memory address.

This is a specialization to implicitly convert function pointer types to printable memory addresses. The output will be zero-padded to the length of addresses on the target architecture. For example:

std::cout << "The address is: " << ptr(&printf) << '\n';

...produces output like:

The address is: 0x00000080DD198C02
Note
It is generally not a good idea to cast function pointers to void* and back because one doesn't know where the memory being pointed to actually physically resides. Some hardware may have separate locations for code segments and data segments. Since we're not actually accessing the memory, but are more interested in the pointer value itself, it's OK to reinterpret the bytes as a void*.
Template Parameters
RThe function's return type.
Args...The full argument list for the function.
Parameters
[in]pThe function pointer format.
Returns
Internal implementation may vary.
internal::swtch_ostream_output_tag psystem::format::swtch ( bool const  s)
inlinenoexcept

Mark output stream data to be formatted as an on/off switch.

Output simply translates a boolean value to a more human-friendly format. For example:

bool const is_true = true;
std::cout << "The is_true switch is set to: " << swtch(is_true) << '\n';

...produces the output:

The is_true switch is set to: on
Parameters
[in]sThe boolean value to format.
Returns
Internal implementation may vary.