Object Serialization

[brendene]

Hello,

Thanks again for the hard work. In https://github.com/odygrd/quill/blob/master/examples/advanced/user_quill_codec.h for the fmtquill::formatter<User> definition, what is the best way to re-use an existing fmt::formatter` definition?

[odygrd]

can you try if this works ? I don't have a separate fmt version installed to try it at the moment

template <>
struct fmtquill::formatter<User> : public fmt::formatter<User>
{
};

[odygrd]

This might also work but i haven't tested it. If you have time give it a try

namespace fmtquill 
{
    template <typename T>
    using formatter = fmt::formatter<T>;
}

[brendene]

I am using your example User class to test it:

In file included from /envs/dev/include/quill/core/Codec.h:12,                                                                                                                                                                                                                                        
                 from /envs/dev/include/quill/Logger.h:10,                                                                                                                                                                                                                                            
                 from /envs/dev/include/quill/Frontend.h:8,                                                                                                                                                                                                                                           
                 from /home/brendene/quill/main.cpp:11:                                                                                                                                                                                                                                               
/envs/dev/include/quill/bundled/fmt/core.h: In instantiation of 'constexpr fmtquill::v10::detail::value<Context> fmtquill::v10::detail::make_arg(T&) [with bool PACKED = true; Context = fmtquill::v10::basic_format_context<fmtquill::v10::appender, char>; T = const User; typename std::enable_if<\
PACKED, int>::type <anonymous> = 0]':                                                                                                                                                                                                                                                                 
/envs/dev/include/quill/bundled/fmt/core.h:1617:39:   required from 'constexpr fmtquill::v10::basic_format_arg<Context> fmtquill::v10::detail::make_arg(T&) [with Context = fmtquill::v10::basic_format_context<fmtquill::v10::appender, char>; T = const User]'                                      
/envs/dev/include/quill/core/DynamicFormatArgStore.h:69:76:   required from 'void quill::detail::DynamicFormatArgStore::emplace_arg(const T&) [with T = User]'                                                                                                                                        
/envs/dev/include/quill/core/DynamicFormatArgStore.h:107:18:   required from 'void quill::detail::DynamicFormatArgStore::push_back(const T&) [with T = User]'                                                                                                                                         
/envs/dev/include/quill/core/Codec.h:432:26:   required from 'void quill::detail::decode_and_assign_members(std::byte*&, DynamicFormatArgStore*, T&, TMembers& ...) [with T = User; TMembers = {std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_\
string<char, std::char_traits<char>, std::allocator<char> >, unsigned int, std::array<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, 3>}]'                                                                                                                          
/home/brendene/quill/user_quill_codec.h:93:30:   required from here                                                                                                                                                                                                                                   
/envs/dev/include/quill/bundled/fmt/core.h:1603:63: error: 'fmtquill::v10::detail::type_is_unformattable_for<const User, char> _' has incomplete type                                                                                                                                                 
 1603 |     type_is_unformattable_for<T, typename Context::char_type> _;                                                                                                                                                                                                                              
      |                                                               ^                                                                                                                                                                                                                               
/envs/dev/include/quill/bundled/fmt/core.h:1607:7: error: static assertion failed: Cannot format an argument. To make type T formattable provide a formatter<T> specialization: https://fmt.dev/latest/api.html#udt                                                                                   
 1607 |       formattable,                                                                                                                                                                                                                                                                            
      |       ^~~~~~~~~~~                                                                                                                                                                                                                                                                             
/envs/dev/include/quill/bundled/fmt/core.h:1607:7: note: 'formattable' evaluates to false                                                                                                                                                                                                             
/envs/dev/include/quill/bundled/fmt/core.h: In instantiation of 'constexpr fmtquill::v10::detail::value<Context> fmtquill::v10::detail::make_arg(T&) [with bool PACKED = true; Context = fmtquill::v10::basic_format_context<fmtquill::v10::appender, char>; T = const std::vector<User>; typename st\
d::enable_if<PACKED, int>::type <anonymous> = 0]':                                                                                                                                                                                                                                                    
/envs/dev/include/quill/bundled/fmt/core.h:1617:39:   required from 'constexpr fmtquill::v10::basic_format_arg<Context> fmtquill::v10::detail::make_arg(T&) [with Context = fmtquill::v10::basic_format_context<fmtquill::v10::appender, char>; T = const std::vector<User>]'                         
/envs/dev/include/quill/core/DynamicFormatArgStore.h:69:76:   required from 'void quill::detail::DynamicFormatArgStore::emplace_arg(const T&) [with T = std::vector<User>]'                                                                                                                           
/envs/dev/include/quill/core/DynamicFormatArgStore.h:107:18:   required from 'void quill::detail::DynamicFormatArgStore::push_back(const T&) [with T = std::vector<User>]'                                                                                                                            
/envs/dev/include/quill/std/Vector.h:94:28:   required from 'static std::vector<_Tp, _Alloc> quill::detail::Decoder<std::vector<_Tp, _Alloc> >::decode(std::byte*&, quill::detail::DynamicFormatArgStore*) [with T = User; Allocator = std::allocator<User>]'                                         
/envs/dev/include/quill/core/Codec.h:389:25:   required from 'void quill::detail::decode(std::byte*&, DynamicFormatArgStore*) [with Args = {std::vector<User, std::allocator<User> >}]'                                                                                                               
/envs/dev/include/quill/core/Codec.h:401:18:   required from 'void quill::detail::decode_and_populate_format_args(std::byte*&, DynamicFormatArgStore&) [with Args = {std::vector<User, std::allocator<User> >}]'                                                                                      
/envs/dev/include/quill/Logger.h:178:31:   required from 'bool quill::LoggerImpl<TFrontendOptions>::log_message(quill::LogLevel, const quill::MacroMetadata*, Args&& ...) [with Args = {const std::vector<User, std::allocator<User> >&}; TFrontendOptions = quill::FrontendOptions]'                 
/home/brendene/quill/main.cpp:56:3:   required from here                                                                                                                                                                                                                                              
/envs/dev/include/quill/bundled/fmt/core.h:1603:63: error: 'fmtquill::v10::detail::type_is_unformattable_for<const std::vector<User>, char> _' has incomplete type                                                                                                                                    
 1603 |     type_is_unformattable_for<T, typename Context::char_type> _;                                                                                                                                                                                                                              
      |                                                               ^                                                                                                                                                                                                                               
/envs/dev/include/quill/bundled/fmt/core.h:1607:7: error: static assertion failed: Cannot format an argument. To make type T formattable provide a formatter<T> specialization: https://fmt.dev/latest/api.html#udt                                                                                   
 1607 |       formattable,                                                                                                                                                                                                                                                                            
      |       ^~~~~~~~~~~                                                                                                                                                                                                                                                                             

[hs-vc]

For me #460 (comment) doesn't work for std::filesystem::path type. Is this expected?

#include "quill/Backend.h"
#include "quill/Frontend.h"
#include "quill/LogMacros.h"
#include "quill/Logger.h"
#include "quill/sinks/ConsoleSink.h"

#include <string>
#include <utility>
#include <filesystem>

#include <fmt/std.h>
#include <fmt/format.h>

template <>
struct fmtquill::formatter<std::filesystem::path> : public fmt::formatter<std::filesystem::path>
{
};


int main() {
    // Start the backend thread
    quill::BackendOptions backend_options;
    quill::Backend::start(backend_options);

    // Frontend
    auto console_sink = quill::Frontend::create_or_get_sink<quill::ConsoleSink>("sink_id_1");
    quill::Logger *logger = quill::Frontend::create_or_get_logger("root", std::move(console_sink));

    // Change the LogLevel to print everything
    logger->set_log_level(quill::LogLevel::TraceL3);
    std::filesystem::path p = "hello";

    LOG_TRACE_L3(logger, "{}", p);
}

[odygrd]

For filesystem it is already supported please include the following file without defining any formatter on your side

https://github.com/odygrd/quill/blob/master/quill/include/quill/std/FilesystemPath.h

If you have any issues let me know

You can use any files from the std folder, you just need to manually include them based on your needs

[hs-vc]

I didn't know that. Thanks!