print_data_RDL.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cinttypes>
#include <cstdio> // for size_t
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <array>
#include <bitset>  // required for Binary conversion
#include <iomanip> // required for std::setprecision 
#include <sstream> // Required for std::ostringstream
 
class Print
{
public:
    Print() : _ErrorFlag(0) {}
 
    enum BaseNum : uint8_t{
        RDL_DEC = 10, 
        RDL_HEX = 16, 
        RDL_OCT = 8,  
        RDL_BIN = 2   
    };
 
    int getWriteError();
    void clearWriteError();
    virtual size_t write(uint8_t) = 0;
    virtual size_t write(const uint8_t *buffer, size_t size);
    size_t write(const char *str);
    size_t write(const char *buffer, size_t size);
    virtual int availableForWrite();
 
    size_t print(const char[]);
    size_t print(char);
    size_t print(int, int = RDL_DEC);
    size_t print(unsigned int, int = RDL_DEC);
    size_t print(long, int = RDL_DEC);
    size_t print(unsigned long, int = RDL_DEC);
    size_t print(double, int = 2);
    size_t print(const std::string &);
 
    size_t println(const char[]);
    size_t println(char);
    size_t println(int, int = RDL_DEC);
    size_t println(unsigned int, int = RDL_DEC);
    size_t println(long, int = RDL_DEC);
    size_t println(unsigned long, int = RDL_DEC);
    size_t println(double, int = 2);
    size_t println(void);
    size_t println(const std::string &s);
 
    template <typename T>
    size_t print(const std::vector<T> &v,  int format = defaultFormat<T>()) {
        size_t totalWritten = 0;
        for (const auto &element : v) {
            std::string elementStr = formatElement(element, format);
            totalWritten += write(elementStr.c_str(), elementStr.length());
 
            // Add a separator space if not the last element
            if (&element != &v.back()) {
                totalWritten += write(" ", 1);
            }
        }
        return totalWritten;
    }
 
    template <typename T>
    size_t println(const std::vector<T> &vec, int format = defaultFormat<T>()) 
    {
        size_t chars = print(vec, format); // Use default format for the type
        chars += print("\r\n");           // Add a newline
        return chars;
    }
 
    template <typename T, size_t N>
    size_t print(const std::array<T, N> &arr, int format = defaultFormat<T>()) 
    {
        return print(std::vector<T>(arr.begin(), arr.end()), format);
    }
    
    template <typename T, size_t N>
    size_t println(const std::array<T, N> &arr, int format = defaultFormat<T>()) {
        // Call print() to print the array elements
        size_t chars = print(arr, format);
        // Print a newline sequence
        chars += print("\r\n");
        return chars;
    }
 
    protected:
 
    void setWriteError(int err = 0);
 
private:
 
    int _ErrorFlag; 
    size_t printNumber(unsigned long, uint8_t);
    size_t printFloat(double, uint8_t);
 
 
template <typename T>
std::string formatElement(const T &element, int format) {
    std::ostringstream oss;
 
    if constexpr (std::is_integral_v<T>) {
        // Handle integral types with base conversion
        switch (format) {
            case RDL_DEC:
                oss << element; // Decimal
                break;
            case RDL_HEX:
                oss << std::hex << std::uppercase << element; // Hexadecimal
                break;
            case RDL_OCT:
                oss << std::oct << element; // Octal
                break;
            case RDL_BIN: {
                // Binary conversion using std::bitset without leading zeros
                std::string binary = std::bitset<sizeof(T) * 8>(element).to_string();
                binary.erase(0, binary.find_first_not_of('0')); // Strip leading zeros
                oss << (binary.empty() ? "0" : binary); // Handle the case for 0
                break;
            }
            default:
                oss << element; // Default to decimal
        }
    } else if constexpr (std::is_floating_point_v<T>) {
        // Handle floating-point types with fixed precision
        oss << std::fixed << std::setprecision(format) << element;
    } else {
        // Handle other types (fallback)
        oss << element;
    }
 
    return oss.str();
}
 
    template <typename T>
    static constexpr int defaultFormat() {
        if constexpr (std::is_floating_point_v<T>) {
            return 2; // Default decimal places for floats/doubles
        } else if constexpr (std::is_integral_v<T>) {
            return RDL_DEC; // Default base for integers
        }
        return 0; // Fallback for unsupported types
    }
 
 
};