fmt::formatter< json_fmt_arg > Class Reference

fmt formatter function for json class able to handle 2 types of formats : {} : in this case the type entry of json is used to deduce what to print, looking into the registry {:name|fmt} : in this case, the entry 'name' of the json will be printed in given format. More...

Collaboration diagram for fmt::formatter< json_fmt_arg >:

Public Member Functions
template<typename ParseContext >
constexpr auto	parse (ParseContext &ctx)
template<typename FormatContext >
auto	format (const json_fmt_arg &json_arg, FormatContext &ctx) const

Private Attributes
std::string	currentFormat
std::string	currentName

Detailed Description

fmt formatter function for json class able to handle 2 types of formats : {} : in this case the type entry of json is used to deduce what to print, looking into the registry {:name|fmt} : in this case, the entry 'name' of the json will be printed in given format.

See comment on registry for more details

Definition at line 107 of file MessageSvcSink.cpp.

Member Function Documentation

format()

template<typename FormatContext >

auto fmt::formatter< json_fmt_arg >::format ( const json_fmt_arg &  json_arg, FormatContext &  ctx  ) const

inline

Definition at line 125 of file MessageSvcSink.cpp.

                                                                        {
    const auto& j = json_arg.payload;
    if ( currentFormat.size() == 0 ) {
      // dealing with {} format, let's find entry for our type in registry
      const auto type = j.at( "type" ).get<std::string>();
      // first looking for the entry, then we drop on ":abc" suffix at a time and try again
      std::string_view type_key{ type };
      // look for the full entry
      auto entry = registry.find( type_key );
      // we check if we have type separators before entering the loop
      auto sep = type_key.rfind( ':' );
      while ( sep != type_key.npos && entry == registry.end() ) {
        // not found, remove the trailing ":abc" section
        type_key.remove_suffix( type_key.size() - sep );
        // check if we have another chunk to strip
        sep = type_key.rfind( ':' );
        // see if the shorter key works
        entry = registry.find( type_key );
      }
      // if still not found, we use the basic "counter"
      if ( entry == registry.end() ) entry = registry.find( "counter" );
      assert( entry != registry.end() );
      // print the json string according to format found
      // This actually will call this formatter again a number of times
      return fmt::format_to( ctx.out(), fmt::runtime( entry->second ), json_arg );
    } else {
      // dealing with a {:name|fmt} format
      auto actualFormat = "{:" + currentFormat + '}';
      switch ( currentFormat.back() ) {
      case 'd':
        return fmt::format_to( ctx.out(), fmt::runtime( actualFormat ),
                               j.at( currentName ).template get<unsigned int>() );
      case 'g':
        return fmt::format_to( ctx.out(), fmt::runtime( actualFormat ), j.at( currentName ).template get<double>() );
      case 'p':
        actualFormat[actualFormat.size() - 2] = 'g';
        return fmt::format_to( ctx.out(), fmt::runtime( actualFormat ),
                               j.at( currentName ).template get<double>() * 100 );
      default:
        return fmt::format_to( ctx.out(), "Unknown counter format : {}", currentFormat );
      }
    }
  }

parse()

template<typename ParseContext >

constexpr auto fmt::formatter< json_fmt_arg >::parse ( ParseContext &  ctx )

inlineconstexpr

Definition at line 110 of file MessageSvcSink.cpp.

                                            {
    auto fmt_begin = ctx.begin();
    auto fmt_end   = std::find( fmt_begin, ctx.end(), '}' );
    if ( fmt_begin == fmt_end ) {
      // we are dealing with {}, only make sure currentFormat is empty
      currentFormat = "";
    } else {
      // non empty format, let's split name from format
      auto fmt_colon = std::find( fmt_begin, fmt_end, '|' );
      currentName    = std::string( fmt_begin, fmt_colon - fmt_begin );
      currentFormat  = std::string( fmt_colon + 1, fmt_end - fmt_colon - 1 );
    }
    return fmt_end;
  }

Member Data Documentation

currentFormat

std::string fmt::formatter< json_fmt_arg >::currentFormat

private

Definition at line 170 of file MessageSvcSink.cpp.

currentName

std::string fmt::formatter< json_fmt_arg >::currentName

private

Definition at line 171 of file MessageSvcSink.cpp.

---

The documentation for this class was generated from the following file:

• GaudiCoreSvc/src/MessageSvc/MessageSvcSink.cpp