class Poco::NumberFormatter

Overview

The NumberFormatter class provides static methods for formatting numeric values into strings. More…

#include <NumberFormatter.h>

class NumberFormatter
{
public:
    // enums

    enum BoolFormat;

    // fields

    static const unsigned NF_MAX_INT_STRING_LEN;
    static const unsigned NF_MAX_FLT_STRING_LEN;

    // methods

    static
    std::string
    format(int value);

    static
    std::string
    format(
        int value,
        int width
        );

    static
    std::string
    format0(
        int value,
        int width
        );

    static
    std::string
    formatHex(
        int value,
        bool prefix = false
        );

    static
    std::string
    formatHex(
        int value,
        int width,
        bool prefix = false
        );

    static
    std::string
    format(unsigned value);

    static
    std::string
    format(
        unsigned value,
        int width
        );

    static
    std::string
    format0(
        unsigned int value,
        int width
        );

    static
    std::string
    formatHex(
        unsigned value,
        bool prefix = false
        );

    static
    std::string
    formatHex(
        unsigned value,
        int width,
        bool prefix = false
        );

    static
    std::string
    format(long value);

    static
    std::string
    format(
        long value,
        int width
        );

    static
    std::string
    format0(
        long value,
        int width
        );

    static
    std::string
    formatHex(
        long value,
        bool prefix = false
        );

    static
    std::string
    formatHex(
        long value,
        int width,
        bool prefix = false
        );

    static
    std::string
    format(unsigned long value);

    static
    std::string
    format(
        unsigned long value,
        int width
        );

    static
    std::string
    format0(
        unsigned long value,
        int width
        );

    static
    std::string
    formatHex(
        unsigned long value,
        bool prefix = false
        );

    static
    std::string
    formatHex(
        unsigned long value,
        int width,
        bool prefix = false
        );

    static
    std::string
    format(float value);

    static
    std::string
    format(
        float value,
        int precision
        );

    static
    std::string
    format(
        float value,
        int width,
        int precision
        );

    static
    std::string
    format(double value);

    static
    std::string
    format(
        double value,
        int precision
        );

    static
    std::string
    format(
        double value,
        int width,
        int precision
        );

    static
    std::string
    format(const void* ptr);

    static
    std::string
    format(
        bool value,
        BoolFormat format = FMT_TRUE_FALSE
        );

    static
    void
    append(
        std::string& str,
        int value
        );

    static
    void
    append(
        std::string& str,
        int value,
        int width
        );

    static
    void
    append0(
        std::string& str,
        int value,
        int width
        );

    static
    void
    appendHex(
        std::string& str,
        int value
        );

    static
    void
    appendHex(
        std::string& str,
        int value,
        int width
        );

    static
    void
    append(
        std::string& str,
        unsigned value
        );

    static
    void
    append(
        std::string& str,
        unsigned value,
        int width
        );

    static
    void
    append0(
        std::string& str,
        unsigned int value,
        int width
        );

    static
    void
    appendHex(
        std::string& str,
        unsigned value
        );

    static
    void
    appendHex(
        std::string& str,
        unsigned value,
        int width
        );

    static
    void
    append(
        std::string& str,
        long value
        );

    static
    void
    append(
        std::string& str,
        long value,
        int width
        );

    static
    void
    append0(
        std::string& str,
        long value,
        int width
        );

    static
    void
    appendHex(
        std::string& str,
        long value
        );

    static
    void
    appendHex(
        std::string& str,
        long value,
        int width
        );

    static
    void
    append(
        std::string& str,
        unsigned long value
        );

    static
    void
    append(
        std::string& str,
        unsigned long value,
        int width
        );

    static
    void
    append0(
        std::string& str,
        unsigned long value,
        int width
        );

    static
    void
    appendHex(
        std::string& str,
        unsigned long value
        );

    static
    void
    appendHex(
        std::string& str,
        unsigned long value,
        int width
        );

    static
    void
    append(
        std::string& str,
        float value
        );

    static
    void
    append(
        std::string& str,
        float value,
        int precision
        );

    static
    void
    append(
        std::string& str,
        float value,
        int width,
        int precision
        );

    static
    void
    append(
        std::string& str,
        double value
        );

    static
    void
    append(
        std::string& str,
        double value,
        int precision
        );

    static
    void
    append(
        std::string& str,
        double value,
        int width,
        int precision
        );

    static
    void
    append(
        std::string& str,
        const void* ptr
        );
};

Detailed Documentation

The NumberFormatter class provides static methods for formatting numeric values into strings.

There are two kind of static member functions:

* format* functions return a std::string containing
  the formatted value.
* append* functions append the formatted value to
  an existing string.

Methods

static
std::string
format(int value)

Formats an integer value in decimal notation.

static
std::string
format(
    int value,
    int width
    )

Formats an integer value in decimal notation, right justified in a field having at least the specified width.

static
std::string
format0(
    int value,
    int width
    )

Formats an integer value in decimal notation, right justified and zero-padded in a field having at least the specified width.

static
std::string
formatHex(
    int value,
    bool prefix = false
    )

Formats an int value in hexadecimal notation.

If prefix is true, “0x” prefix is prepended to the resulting string. The value is treated as unsigned.

static
std::string
formatHex(
    int value,
    int width,
    bool prefix = false
    )

Formats a int value in hexadecimal notation, right justified and zero-padded in a field having at least the specified width.

If prefix is true, “0x” prefix is prepended to the resulting string. The value is treated as unsigned.

static
std::string
format(unsigned value)

Formats an unsigned int value in decimal notation.

static
std::string
format(
    unsigned value,
    int width
    )

Formats an unsigned long int in decimal notation, right justified in a field having at least the specified width.

static
std::string
format0(
    unsigned int value,
    int width
    )

Formats an unsigned int value in decimal notation, right justified and zero-padded in a field having at least the specified width.

static
std::string
formatHex(
    unsigned value,
    bool prefix = false
    )

Formats an unsigned int value in hexadecimal notation.

If prefix is true, “0x” prefix is prepended to the resulting string.

static
std::string
formatHex(
    unsigned value,
    int width,
    bool prefix = false
    )

Formats a int value in hexadecimal notation, right justified and zero-padded in a field having at least the specified width.

If prefix is true, “0x” prefix is prepended to the resulting string.

static
std::string
format(long value)

Formats a long value in decimal notation.

static
std::string
format(
    long value,
    int width
    )

Formats a long value in decimal notation, right justified in a field having at least the specified width.

static
std::string
format0(
    long value,
    int width
    )

Formats a long value in decimal notation, right justified and zero-padded in a field having at least the specified width.

static
std::string
formatHex(
    long value,
    bool prefix = false
    )

Formats an unsigned long value in hexadecimal notation.

If prefix is true, “0x” prefix is prepended to the resulting string. The value is treated as unsigned.

static
std::string
formatHex(
    long value,
    int width,
    bool prefix = false
    )

Formats an unsigned long value in hexadecimal notation, right justified and zero-padded in a field having at least the specified width.

If prefix is true, “0x” prefix is prepended to the resulting string. The value is treated as unsigned.

static
std::string
format(unsigned long value)

Formats an unsigned long value in decimal notation.

static
std::string
format(
    unsigned long value,
    int width
    )

Formats an unsigned long value in decimal notation, right justified in a field having at least the specified width.

static
std::string
format0(
    unsigned long value,
    int width
    )

Formats an unsigned long value in decimal notation, right justified and zero-padded in a field having at least the specified width.

static
std::string
formatHex(
    unsigned long value,
    bool prefix = false
    )

Formats an unsigned long value in hexadecimal notation.

If prefix is true, “0x” prefix is prepended to the resulting string.

static
std::string
formatHex(
    unsigned long value,
    int width,
    bool prefix = false
    )

Formats an unsigned long value in hexadecimal notation, right justified and zero-padded in a field having at least the specified width.

If prefix is true, “0x” prefix is prepended to the resulting string.

static
std::string
format(float value)

Formats a float value in decimal floating-point notation, according to std::printf’s g format with a precision of 8 fractional digits.

static
std::string
format(
    float value,
    int precision
    )

Formats a double value in decimal floating-point notation, according to std::printf’s f format with the given precision.

static
std::string
format(
    float value,
    int width,
    int precision
    )

Formats a double value in decimal floating-point notation, right justified in a field of the specified width, with the number of fractional digits given in precision.

static
std::string
format(double value)

Formats a double value in decimal floating-point notation, according to std::printf’s g format with a precision of 16 fractional digits.

static
std::string
format(
    double value,
    int precision
    )

Formats a double value in decimal floating-point notation, according to std::printf’s f format with the given precision.

static
std::string
format(
    double value,
    int width,
    int precision
    )

Formats a double value in decimal floating-point notation, right justified in a field of the specified width, with the number of fractional digits given in precision.

static
std::string
format(const void* ptr)

Formats a pointer in an eight (32-bit architectures) or sixteen (64-bit architectures) characters wide field in hexadecimal notation.

static
std::string
format(
    bool value,
    BoolFormat format = FMT_TRUE_FALSE
    )

Formats a bool value in decimal/text notation, according to format parameter.

static
void
append(
    std::string& str,
    int value
    )

Formats an integer value in decimal notation.

static
void
append(
    std::string& str,
    int value,
    int width
    )

Formats an integer value in decimal notation, right justified in a field having at least the specified width.

static
void
append0(
    std::string& str,
    int value,
    int width
    )

Formats an integer value in decimal notation, right justified and zero-padded in a field having at least the specified width.

static
void
appendHex(
    std::string& str,
    int value
    )

Formats an int value in hexadecimal notation.

The value is treated as unsigned.

static
void
appendHex(
    std::string& str,
    int value,
    int width
    )

Formats a int value in hexadecimal notation, right justified and zero-padded in a field having at least the specified width.

The value is treated as unsigned.

static
void
append(
    std::string& str,
    unsigned value
    )

Formats an unsigned int value in decimal notation.

static
void
append(
    std::string& str,
    unsigned value,
    int width
    )

Formats an unsigned long int in decimal notation, right justified in a field having at least the specified width.

static
void
append0(
    std::string& str,
    unsigned int value,
    int width
    )

Formats an unsigned int value in decimal notation, right justified and zero-padded in a field having at least the specified width.

static
void
appendHex(
    std::string& str,
    unsigned value
    )

Formats an unsigned int value in hexadecimal notation.

static
void
appendHex(
    std::string& str,
    unsigned value,
    int width
    )

Formats a int value in hexadecimal notation, right justified and zero-padded in a field having at least the specified width.

static
void
append(
    std::string& str,
    long value
    )

Formats a long value in decimal notation.

static
void
append(
    std::string& str,
    long value,
    int width
    )

Formats a long value in decimal notation, right justified in a field having at least the specified width.

static
void
append0(
    std::string& str,
    long value,
    int width
    )

Formats a long value in decimal notation, right justified and zero-padded in a field having at least the specified width.

static
void
appendHex(
    std::string& str,
    long value
    )

Formats an unsigned long value in hexadecimal notation.

The value is treated as unsigned.

static
void
appendHex(
    std::string& str,
    long value,
    int width
    )

Formats an unsigned long value in hexadecimal notation, right justified and zero-padded in a field having at least the specified width.

The value is treated as unsigned.

static
void
append(
    std::string& str,
    unsigned long value
    )

Formats an unsigned long value in decimal notation.

static
void
append(
    std::string& str,
    unsigned long value,
    int width
    )

Formats an unsigned long value in decimal notation, right justified in a field having at least the specified width.

static
void
append0(
    std::string& str,
    unsigned long value,
    int width
    )

Formats an unsigned long value in decimal notation, right justified and zero-padded in a field having at least the specified width.

static
void
appendHex(
    std::string& str,
    unsigned long value
    )

Formats an unsigned long value in hexadecimal notation.

static
void
appendHex(
    std::string& str,
    unsigned long value,
    int width
    )

Formats an unsigned long value in hexadecimal notation, right justified and zero-padded in a field having at least the specified width.

static
void
append(
    std::string& str,
    float value
    )

Formats a float value in decimal floating-point notation, according to std::printf’s g format with a precision of 8 fractional digits.

static
void
append(
    std::string& str,
    float value,
    int precision
    )

Formats a double value in decimal floating-point notation, according to std::printf’s f format with the given precision.

static
void
append(
    std::string& str,
    float value,
    int width,
    int precision
    )

Formats a double value in decimal floating-point notation, right justified in a field of the specified width, with the number of fractional digits given in precision.

static
void
append(
    std::string& str,
    double value
    )

Formats a double value in decimal floating-point notation, according to std::printf’s g format with a precision of 16 fractional digits.

static
void
append(
    std::string& str,
    double value,
    int precision
    )

Formats a double value in decimal floating-point notation, according to std::printf’s f format with the given precision.

static
void
append(
    std::string& str,
    double value,
    int width,
    int precision
    )

Formats a double value in decimal floating-point notation, right justified in a field of the specified width, with the number of fractional digits given in precision.

static
void
append(
    std::string& str,
    const void* ptr
    )

Formats a pointer in an eight (32-bit architectures) or sixteen (64-bit architectures) characters wide field in hexadecimal notation.