BasicFormatter.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Detail/BasicString.hxx"
#include "Arp/Base/Core/Detail/fmt_cast.hxx"
#include <fmt/format.h>
#include <fmt/ostream.h>
#include <fmt/printf.h>
#include <functional>
 
#ifndef ARP_INSIDE_ARP_BASE_CORE_ARP_H
    #error Never include 'BasicFormatter.hxx' directly, just include 'Arp.hpp'
#endif
 
namespace Arp { namespace Base { namespace Core
{
 
 
// forwards
template<typename C, typename A> class BasicString;
 
template<typename C, typename A = std::allocator<C>>
class BasicFormatter
{
public: // usings
    using CharType = C; 
    using StringType = BasicString<C, A>; 
    using ExceptionHandler = void(*)(const char*, const char*); 
 
public:
    template<typename... Args>
    static StringType FormatCommon(ExceptionHandler exceptionHandler, const StringType& format, Args&& ... args);
 
    template<typename... Args>
    static StringType FormatCommon(ExceptionHandler exceptionHandler, const CharType* format, Args&& ... args);
 
    template<typename... Args>
    static StringType FormatPrintf(ExceptionHandler exceptionHandler, const StringType& format, Args&& ... args);
 
    template<typename... Args>
    static StringType FormatPrintf(ExceptionHandler exceptionHandler, const CharType* format, Args&& ... args);
};
 
// inline methods of class BasicFormatter
template<typename C, typename A>
template<typename... Args>
inline typename BasicFormatter<C, A>::StringType BasicFormatter<C, A>::FormatCommon(ExceptionHandler exceptionHandler, const StringType& format, Args&& ... args)
{
    return BasicFormatter::FormatCommon(exceptionHandler, format.CStr(), std::forward<Args>(args)...);
}
 
template<typename C, typename A>
template<typename... Args>
inline typename BasicFormatter<C, A>::StringType BasicFormatter<C, A>::FormatCommon(ExceptionHandler exceptionHandler, const CharType* format, Args&& ... args)
{
    try
    {
        return fmt::format(fmt::runtime(format), fmt_cast(std::forward<Args>(args))...);
    }
    catch (std::exception& e)
    {
        exceptionHandler(format, e.what());
        return StringType();
    }
}
 
template<typename C, typename A>
template<typename... Args>
inline typename BasicFormatter<C, A>::StringType BasicFormatter<C, A>::FormatPrintf(ExceptionHandler exceptionHandler, const StringType& format, Args&& ... args)
{
    return BasicFormatter<C, A>::FormatPrintf(exceptionHandler, format.CStr(), std::forward<Args>(args)...);
}
 
template<typename C, typename A>
template<typename... Args>
inline typename BasicFormatter<C, A>::StringType BasicFormatter<C, A>::FormatPrintf(ExceptionHandler exceptionHandler, const CharType* format, Args&& ... args)
{
    try
    {
        return fmt::sprintf(format, fmt_cast(std::forward<Args>(args))...);
    }
    catch (std::exception& e)
    {
        exceptionHandler(format, e.what());
        return StringType();
    }
}
 
}}} // end of namespace Arp::Base::Core
 
namespace fmt
{
}