C++ string Formatter Again Part-4

Question

Previously asked here.

The code is now available on GitHub.

Since the previous review I have added unit tests.

Since it is big it will come in a couple of parts.

Part 1 | Part 2 | Part 3 | Part 4

Part 4

Printing strings and integers did not work the same way on streams as they did in printf(). So I had to write some special handling code to deal with these types to get the unit tests to all work.

printToStream.h

#ifndef THORSANVIL_IOUTIL_PRINT_TO_STREAM_H
#define THORSANVIL_IOUTIL_PRINT_TO_STREAM_H
#include "FormatInfo.h"
#include "printIntToStream.h"
#include "printStringToStream.h"
#include <ostream>
namespace ThorsAnvil::IOUtil
{
template<typename T>
inline void printToStreamDefault(std::ostream& s, T const& arg, FormatInfo const&)
{
 s << arg;
}
/* Template method for everything apart from integers */
template<typename T>
inline
typename std::enable_if<!std::is_integral<T>::value>::type
printToStream(std::ostream& s, T const& arg, FormatInfo const& info)
{
 // Just use the standard stream printing methods.
 // Below we special case Int and string handling (floats work as expected).
 printToStreamDefault(s, arg, info);
}
/*
 * As a char is an integer we need to detect this case
 * and call the standard printing functions for Type::Char
 *
 * But we can also print an integer using a char in which case we need to convert the char to an integer
 * before we can print it. Below are helper functions to convert Char to Int when printing a char as an
 * an integer.
 */
template<typename T>
struct CharIntConverter
{
 using Integer = T;
};
template<>
struct CharIntConverter<char>
{
 using Integer = int;
};
template<>
struct CharIntConverter<unsigned char>
{
 using Integer = unsigned int;
};
template<typename T>
inline
typename std::enable_if<std::is_integral<T>::value>::type
printToStream(std::ostream& s, T const& arg, FormatInfo const& info)
{
 if (info.type == Type::Char)
 {
 printToStreamDefault(s, static_cast<char>(arg), info);
 }
 else
 {
 printIntToStream(s, static_cast<typename CharIntConverter<T>::Integer>(arg), info);
 }
}
// C-String
inline void printToStream(std::ostream& s, char const* const& arg, FormatInfo const& info)
{
 printStringToStream(s, arg, info);
}
}
#endif

PrintStringToStream.h

#ifndef THORSANVIL_IOUTIL_PRINT_STRING_TO_STREAM_H
#define THORSANVIL_IOUTIL_PRINT_STRING_TO_STREAM_H
#include "FormatInfo.h"
#include "printToStream.h"
namespace ThorsAnvil::IOUtil
{
inline void printStringToStream(std::ostream& s, char const* const& arg, FormatInfo const& info)
{
 if (info.precision == -1)
 {
 s << arg;
 }
 else
 {
 s.width(0);
 std::size_t padding = (info.precision >= info.width) ? 0 : (info.width - info.precision);
 if (!info.leftJustify)
 {
 for (std::size_t loop = 0; loop < padding; ++loop)
 {
 s.put(' ');
 }
 }
 for (std::size_t loop = 0; arg[loop] != '0円' && loop < info.precision; ++loop)
 {
 s.put(arg[loop]);
 }
 if (info.leftJustify)
 {
 for (std::size_t loop = 0; loop < padding; ++loop)
 {
 s.put(' ');
 }
 }
 }
}
}

PrintIntToStream

#ifndef THORSANVIL_IOUTIL_PRINT_INT_TO_STREAM_H
#define THORSANVIL_IOUTIL_PRINT_INT_TO_STREAM_H
#include "FormatInfo.h"
#include "printToStream.h"
#include <ostream>
#include <cmath>
namespace ThorsAnvil::IOUtil
{
inline long long absm(long long arg) {return std::abs(arg);}
inline long absm(long arg) {return std::abs(arg);}
inline int absm(int arg) {return std::abs(arg);}
inline unsigned long long absm(unsigned long long arg) {return arg;}
inline unsigned long absm(unsigned long arg) {return arg;}
inline unsigned int absm(unsigned int arg) {return arg;}
template<typename T>
inline void printIntToStream(std::ostream& s, T arg, FormatInfo const& info)
{
 static long double const logFor16 = std::log10(16.0L);
 static long double const logFor10 = std::log10(10.0L);
 static long double const logFor08 = std::log10(8.0L);
 double const& logBase = s.flags() & std::ios_base::oct ? logFor08 : s.flags() & std::ios_base::hex ? logFor16 : logFor10;
 if (info.width == 0 && info.precision == -1)
 {
 s << arg;
 }
 else
 {
 std::size_t width = info.width;
 std::size_t precision = info.precision;
 /*
 * When precision or Width are specified the default does not do the same as C sprintf library
 * So we are going to take care of it manually here
 * So turn off the standard printing functions
 */
 s.width(0);
 s.unsetf(std::ios_base::showpos | std::ios_base::showbase);
 // extraChar extra charters we are forced to print. +- 0x
 // extraDigits extra digits we are forced to print prefix 0 for octal numbers
 std::size_t extraChar = (arg < 0) || (arg >=0 && info.forceSign && info.type == Type::Int) ? 1 : 0;
 std::size_t extraDigits = 0;
 if (info.prefixType)
 {
 switch (s.flags() & std::ios_base::basefield)
 {
 case std::ios_base::hex: extraChar += 2;break;
 case std::ios_base::oct: extraDigits += 1;break;
 }
 }
 /*
 * Number of digits to print
 * If arg is not zero use logs to calculate the number of digits.
 * If it is zero then the size is 1 unless the precision is zero (a zero value with zero precision prints nothing)
 */
 width = extraChar > width ? 0 : width - extraChar;
 std::size_t numberOfDigits = (arg != 0 ? static_cast<int>((std::log10(static_cast<long double>(absm(arg))) / logBase + 1)) : (precision == 0 ? 0 : 1)) + extraDigits;
 std::size_t sizeOfNumber = precision == -1 || numberOfDigits > precision ? numberOfDigits : precision;
 std::size_t prefix = precision == -1 || numberOfDigits > precision ? 0 : (precision - numberOfDigits);
 std::size_t padding = (sizeOfNumber >= width) ? 0 : (width - sizeOfNumber);
 if (precision == -1 && info.leftPad && !info.leftJustify)
 {
 std::swap(prefix, padding);
 }
 // Add spaces before number to make it fit in width.
 if (!info.leftJustify)
 {
 for (std::size_t loop = 0; loop < padding; ++loop)
 {
 s.put(' ');
 }
 }
 // Add the - or + sign if required.
 if (arg < 0)
 {
 s.put('-');
 }
 else if (arg >=0 && info.forceSign && info.type == Type::Int)
 {
 s.put('+');
 }
 // Add the Octal or Hex prefix
 if (info.prefixType)
 {
 if (s.flags() & (std::ios_base::hex | std::ios_base::oct))
 {
 s.put('0');
 }
 if (s.flags() & std::ios_base::hex)
 {
 s.put(s.flags() & std::ios_base::uppercase ? 'X' : 'x');
 }
 }
 // Add any prefix 0 needed.
 for (std::size_t loop = 0; loop < prefix; ++loop)
 {
 s.put('0');
 }
 // Print out the absolute value (we have already printed the sign)
 // Don't print anything if precision is 0 and value is 0
 if (precision != 0 || arg != 0)
 {
 s << absm(arg);
 }
 // Add spaces after number to make it fit in width.
 if (info.leftJustify)
 {
 for (std::size_t loop = 0; loop < padding; ++loop)
 {
 s.put(' ');
 }
 }
 }
}
}
#endif