315 lines
10 KiB
C++
315 lines
10 KiB
C++
/*!
|
|
* \file utils/print.h
|
|
* \brief
|
|
* A CRTP base class to provide print interface
|
|
*
|
|
* \copyright Copyright (C) 2021 Christos Choutouridis <christos@choutouridis.net>
|
|
*
|
|
* <dl class=\"section copyright\"><dt>License</dt><dd>
|
|
* The MIT License (MIT)
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in all
|
|
* copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
* SOFTWARE.
|
|
* </dd></dl>
|
|
*/
|
|
|
|
#ifndef TBX_UTILS_PRINT_H_
|
|
#define TBX_UTILS_PRINT_H_
|
|
|
|
#include <core/core.h>
|
|
#include <core/crtp.h>
|
|
|
|
#include <cstring>
|
|
#include <math.h>
|
|
#include <string_view>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
#include <limits>
|
|
|
|
namespace tbx {
|
|
|
|
/*!
|
|
* \class Print
|
|
* \brief
|
|
* A CRTP print interface
|
|
*
|
|
* Requirements:
|
|
* - size_t write_impl(const Char_t* buffer, size_t size) : Return the number of \c Char_t written
|
|
* - size_t write_(const Char_t ch) : Return the number of \c Char_t written (normally one).
|
|
*
|
|
* \tparam Impl_t The derived type
|
|
* \tparam Char_t The char type to use
|
|
*/
|
|
template <typename Impl_t, typename Char_t>
|
|
class Print {
|
|
_CRTP_IMPL(Impl_t);
|
|
|
|
public:
|
|
using value_type = Char_t;
|
|
using pointer_type = Char_t*;
|
|
using iterator_type = Char_t*;
|
|
using const_iterator_type = const Char_t*;
|
|
using difference_type = std::ptrdiff_t;
|
|
using size_type = size_t;
|
|
using str_view_t = std::basic_string_view<Char_t>;
|
|
|
|
//! Enumerator for number base formating
|
|
enum class Base {
|
|
BIN =2, OCT =8, DEC =10, HEX =16
|
|
};
|
|
|
|
private:
|
|
//! \name CRTP requirements
|
|
//! @{
|
|
size_t write_(const Char_t* buffer, size_t size) {
|
|
return impl().write_impl(buffer, size);
|
|
}
|
|
size_t write_(const Char_t ch) {
|
|
return impl().write_impl(ch);
|
|
}
|
|
//! @}
|
|
|
|
protected:
|
|
Print() noexcept = default; //!< Construct from derived only
|
|
|
|
private:
|
|
//! Helper tool to convert strong enums to their underlying type
|
|
template <typename E>
|
|
constexpr typename std::underlying_type_t<E> value(E e) noexcept {
|
|
return static_cast<typename std::underlying_type_t<E>>(e);
|
|
}
|
|
|
|
size_t print_unsigned(unsigned long n, Base base); // integer conversion base tool
|
|
size_t print_double(double number, uint8_t digits); // double conversion base tool
|
|
|
|
public:
|
|
/*!
|
|
* \brief
|
|
* Prints a string view
|
|
* \param str The string view to print
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(const str_view_t str) {
|
|
return write_(str.data(), str.size());
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Prints a string
|
|
* \param str Pointer to string to print
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(const Char_t* str) {
|
|
if (str == nullptr)
|
|
return 0;
|
|
return write_(str, std::strlen(str));
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Prints a buffer of size \c size. If there is a null termination
|
|
* before the end of the buffer, prints up to termination.
|
|
*
|
|
* \param str Pointer to string buffer to print
|
|
* \param size The size of buffer
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(const Char_t* str, size_t size) {
|
|
if (str == nullptr)
|
|
return 0;
|
|
return write_(str, size);
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Prints a \c Char_t
|
|
* \param ch The Char_t to print
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(Char_t ch) {
|
|
return write_ (ch);
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Convert and print a long.
|
|
* \param n The number to print
|
|
* \param base The number base to use for conversion.
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(long n, Base base =Base::DEC) {
|
|
size_t cnt =0;
|
|
if (n < 0) {
|
|
n = -n;
|
|
cnt = write_ ('-');
|
|
}
|
|
return cnt + print_unsigned((unsigned long)n, base);
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Convert and print an int.
|
|
* \param n The number to print
|
|
* \param base The number base to use for conversion.
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(int n, Base base= Base::DEC) {
|
|
return print ((long)n, base);
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Convert and print an unsigned long.
|
|
* \param n The number to print
|
|
* \param base The number base to use for conversion.
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(unsigned long n, Base base= Base::DEC) {
|
|
return print_unsigned ((unsigned long)n, base);
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Convert and print an unsigned int.
|
|
* \param n The number to print
|
|
* \param base The number base to use for conversion.
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(unsigned int n, Base base= Base::DEC) {
|
|
return print_unsigned ((unsigned long)n, base);
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Convert and print adouble
|
|
* \param n The number to print
|
|
* \param digits The number of decimal digits to print
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
size_t print(double n, uint8_t digits = 2) {
|
|
return print_double (n, digits);
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Perfect forwarder to print functionality with a new line termination
|
|
* \tparam Ts The types of parameters
|
|
* \param args The arguments to pass
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
template <typename ...Ts>
|
|
size_t println(Ts&& ...args) {
|
|
size_t r = print (std::forward<Ts>(args)...);
|
|
r += write_ ('\n');
|
|
return r;
|
|
}
|
|
};
|
|
|
|
/*!
|
|
* \brief
|
|
* Converts and prints an unsigned long
|
|
*
|
|
* \tparam Impl_t The derived type
|
|
* \tparam Char_t The char type to use
|
|
*
|
|
* \param n The number to print
|
|
* \param base The number base to use
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
template <typename Impl_t, typename Char_t>
|
|
size_t Print<Impl_t, Char_t>::print_unsigned(unsigned long n, Base base) {
|
|
Char_t buf[8 *sizeof(Char_t) * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
|
|
Char_t *str = &buf[sizeof(buf) - 1];
|
|
|
|
*str = '\0';
|
|
|
|
do {
|
|
Char_t c = n % value(base);
|
|
n /= value(base);
|
|
|
|
*--str = c < 10 ? c + '0' : c + 'A' - 10;
|
|
} while(n);
|
|
|
|
return write_(str, std::strlen(str));
|
|
}
|
|
|
|
/*!
|
|
* \brief
|
|
* Converts and prints a double
|
|
*
|
|
* \note
|
|
* Internally, this implementation uses a long to store the integer part of the number.
|
|
* Thus overflows for numbers bigger than std::numeric_limits<long>::max() / min().
|
|
* For these numbers it prints "ovf" instead.
|
|
*
|
|
* \tparam Impl_t The derived type
|
|
* \tparam Char_t The char type to use
|
|
*
|
|
* \param n The number to print
|
|
* \param digits The number of decimal digits to print
|
|
* \return The number of printed \c Char_t
|
|
*/
|
|
template <typename Impl_t, typename Char_t>
|
|
size_t Print<Impl_t, Char_t>::print_double(double number, uint8_t digits) {
|
|
size_t n = 0;
|
|
|
|
if (std::isnan(number)) return print("nan");
|
|
if (std::isinf(number)) return print("inf");
|
|
if (number > (double)std::numeric_limits<long>::max())
|
|
return print ("ovf");
|
|
if (number < (double)std::numeric_limits<long>::min())
|
|
return print ("-ovf");
|
|
|
|
// Handle negative numbers
|
|
if (number < 0.0) {
|
|
n += write_ ('-');
|
|
number = -number;
|
|
}
|
|
|
|
// Round correctly so that print(1.999, 2) prints as "2.00"
|
|
double rounding = 0.5;
|
|
for (uint8_t i=0; i<digits; ++i)
|
|
rounding /= 10.0;
|
|
|
|
number += rounding;
|
|
|
|
// Extract the integer part of the number and print it
|
|
unsigned long int_part = (unsigned long)number;
|
|
double remainder = number - (double)int_part;
|
|
n += print(int_part);
|
|
|
|
// Print the decimal point, but only if there are digits beyond
|
|
if (digits > 0) {
|
|
n += print('.');
|
|
}
|
|
|
|
// Extract digits from the remainder one at a time
|
|
while (digits-- > 0) {
|
|
remainder *= 10.0;
|
|
unsigned int toPrint = (unsigned int)(remainder);
|
|
n += print(toPrint);
|
|
remainder -= toPrint;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
|
|
}
|
|
#endif /* TBX_UTILS_PRINT_H_ */
|