EXT C++ Library - echo

The echo construct is introduced to convert values to strings. The conversion is defined for all built-in types and for some library classes. Output type can be std::string or std::wstring.

Interface:


            template <typename C>

            class ext::common_echo : public std::basic_string <C> {

            public:

                common_echo (const char *, C invalid = '?');

                common_echo (const wchar_t *, C invalid = '?');

                common_echo (const std::basic_string <char> &, C invalid = '?');

                common_echo (const std::basic_string <wchar_t> &, C invalid = '?');

            

                template <typename T>

                common_echo (const T *);

            

                common_echo (bool, ext::echo_format = ext::default_format);

            

                common_echo (char);

                common_echo (wchar_t);

            

                common_echo (signed char,  echo_format = default_format, unsigned int = 0, C=0);

                common_echo (signed short, echo_format = default_format, unsigned int = 0, C=0);

                common_echo (signed int,   echo_format = default_format, unsigned int = 0, C=0);

                common_echo (signed long,  echo_format = default_format, unsigned int = 0, C=0);

                common_echo (const signed long long &, echo_format = default_format,

                             unsigned int = 0, C = 0);

            

                common_echo (unsigned char,  echo_format = default_format, unsigned int = 0, C=0);

                common_echo (unsigned short, echo_format = default_format, unsigned int = 0, C=0);

                common_echo (unsigned int,   echo_format = default_format, unsigned int = 0, C=0);

                common_echo (unsigned long,  echo_format = default_format, unsigned int = 0, C=0);

                common_echo (const unsigned long long &, echo_format = default_format,

                             unsigned int = 0, C = 0);

            

                common_echo (float,                   ext::echo_format = ext::default_format,

                             unsigned int = 0, unsigned int = 0, C = 0);

                common_echo (const double &,      ext::echo_format = ext::default_format,

                             unsigned int = 0, unsigned int = 0, C = 0);

                common_echo (const long double &, ext::echo_format = ext::default_format,

                             unsigned int = 0, unsigned int = 0, C = 0);

            

                template <typename T>

                common_echo (const std::complex <T> &);

            

                common_echo (const std::type_info &);

                common_echo (const std::tm &);

            

                common_echo (const std::exception &);

            };

            

            typedef ext::common_echo <char>     ext::echo;

            typedef ext::common_echo <wchar_t>  ext::wecho;

Details:

The ext::echo constructs from one parameter of any of supported type (and optional parameters that control the string format) and then behaves like std::basic_string.

Use ext::echo when converting to std::string, use ext::wecho when converting to std::wstring.

Following groups of input types are supported:

Strings

const char *
NUL-terminated ASCII character string
const wchar_t *
Wide-character NUL-terminated ASCIIZ string
const std::string &
const std::wstring &

The second parameter invalid specifies a character which is used in place of any character that failed to be converted from input representation to output representation. This may happen for example for an international UNICODE character that is not contained in destination charset when converting from wchar_t to char.

Pointer

const T *
A pointer of any type is converted to hexadecimal C number as printf would do given the "0x%p" format string.

Boolean value

bool
If the second parameter is ext::hexadecimal_format or ext::octal_format then a "1" string is returned when the value is true and "0" when the value is false. Otherwise "true" or "false" is returned based on the value.

Single character

char - Same as one character long string containing the character
wchar_t - Same as one character long string containing this wide character

Signed or unsigned number

signed char
signed short
signed int
signed long
signed long long
unsigned char
unsigned short
unsigned int
unsigned long
unsigned long long

These conversions may take three following additional parameters:

echo_format
First parameter. Specify one of ext::default_format, ext::hexadecimal_format, ext::uppercase_hexadecimal_format or ext::octal_format to get appropriate format.
width
Second parameter. Minimum width of column for the number (left padding). Corresponds to printf.
padding
Third parameter. Padding character, only space and zero are currently supported due to mapping to std::snprintf function.

Floating point numbers

float
double
long double

These conversions may take four following additional parameters:

echo_format
First parameter. Specify one of ext::default_format, ext::scientific_format or ext::uppercase_scientific_format to get appropriate format.
width
Second parameter. Minimum width of column for the number (left padding). Corresponds to printf.
precision
Third parameter. Precission of the floating point number. Corresponds to printf.
padding
Fourth parameter. Padding character, only space and zero are currently supported due to mapping to std::snprintf function.

Complex number

const std::complex <?> &
Formatted as "(r,i)" where r is real part and i is the imaginary part.

Other library types

const std::type_info & - runtime name type (.name())
const std::tm & - D.M.YYYY HH:MM:SS represenation of date and time
const std::exception & - exception text (.what())

Examples:


            #include <ext/c++>

            

            int main () {

                std::printf ("%s\n", ext::echo ((void *) 0).c_str ());

                std::printf ("%s\n", ext::echo (-7).c_str ());

                std::printf ("%s\n", ext::echo (123, ext::hexadecimal_format).c_str ());

                std::printf ("%s\n", ext::echo (L"wide-char text").c_str ());

            

                std::time_t t = std::time (NULL);

                std::printf ("%s\n", ext::echo (*localtime (&t)).c_str ());

            

                return 0;

            };

Remarks

The ext::echo and ext::wecho are implemented as typedefs for template ext::common_echo <T> where T is char or wchar_t respectively.

Note that to achieve full compatibility with std::string and std::wstring, the ext::common_echo is publicly derived from std::basic_string. Although this is bad practice in most cases, to avoid most common problems the ext::common_echo disallows its dynamic allocation.

The ext::common_echo does not introduce any public nor private data members to its std::basic_string base class and all conversions are computed in constructors.

[index]