BasicFormatter.hxx

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "cppformat/format.h"
#include <memory>
 
#ifndef ARP_INSIDE_ARP_H
    #error Never include 'BasicFormatter.hxx' directly, just include 'Arp.h'
#endif
 
namespace Arp
{
 
// 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 = std::function<void(const char*, const char*)>; 
 
public:
    template<typename... Args>
    static StringType FormatCommon(ExceptionHandler exceptionHandler, const StringType& format, const Args& ... args);
 
    template<typename... Args>
    static StringType FormatCommon(ExceptionHandler exceptionHandler, const CharType* format, const Args& ... args);
 
    template<typename... Args>
    static StringType FormatPrintf(ExceptionHandler exceptionHandler, const StringType& format, const Args& ... args);
 
    template<typename... Args>
    static StringType FormatPrintf(ExceptionHandler exceptionHandler, const CharType* format, const 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, const Args& ... args)
{
    return BasicFormatter::FormatCommon(exceptionHandler, format.CStr(), args...);
}
 
template<typename C, typename A>
template<typename... Args>
inline typename BasicFormatter<C, A>::StringType BasicFormatter<C, A>::FormatCommon(ExceptionHandler exceptionHandler, const CharType* format, const Args& ... args)
{
    try
    {
        return fmt::format(format, 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, const Args& ... args)
{
    return BasicFormatter<C, A>::FormatPrintf(exceptionHandler, format.CStr(), args...);
}
 
template<typename C, typename A>
template<typename... Args>
inline typename BasicFormatter<C, A>::StringType BasicFormatter<C, A>::FormatPrintf(ExceptionHandler exceptionHandler, const CharType* format, const Args& ... args)
{
    try
    {
        return fmt::sprintf(format, args...);
    }
    catch (std::exception& e)
    {
        exceptionHandler(format, e.what());
        return StringType();
    }
}
 
} // end of namespace Arp