PropertyFmt.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 2023-2026 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once

 
#include <Gaudi/Property.h>
#include <fmt/format.h>
#include <fmt/ranges.h>
#include <format>
#include <iomanip>
#include <sstream>
 
// Disable fmt's automatic range formatting for Gaudi::Property
// This prevents ambiguity with fmt 11+ which auto-detects ranges
template <typename T, typename V, typename H, typename Char>
struct fmt::is_range<Gaudi::Property<T, V, H>, Char> : std::false_type {};
 
#define GAUDI_PROPERTY_FORMATTING_IMPL( ns, assert_for_ranges )                                                        \
  template <typename T, typename V, typename H>                                                                        \
  struct ns::formatter<Gaudi::Property<T, V, H>> : ns::formatter<T> {                                                  \
    assert_for_ranges;                                                                                                 \
    bool           debug = false;                                                                                      \
    constexpr auto parse( ns::format_parse_context& ctx ) {                                                            \
      auto it = ctx.begin(), end = ctx.end();                                                                          \
      if ( it != end && *it == '?' ) {                                                                                 \
        debug = true;                                                                                                  \
        ++it;                                                                                                          \
        if ( it != end && *it != '}' ) throw ns::format_error( "invalid format" );                                     \
        return it;                                                                                                     \
      }                                                                                                                \
      return ns::formatter<T>::parse( ctx );                                                                           \
    }                                                                                                                  \
    auto format( const Gaudi::Property<T, V, H>& p, ns::format_context& ctx ) const {                                  \
      if ( debug ) {                                                                                                   \
        if constexpr ( std::is_same_v<T, std::string> ) {                                                              \
          std::stringstream s;                                                                                         \
          s << std::quoted( p.value(), '\'' );                                                                         \
          return ns::format_to( ctx.out(), " '{}':{}", p.name(), s.str() );                                            \
        } else {                                                                                                       \
          return ns::format_to( ctx.out(), " '{}':{}", p.name(), p.value() );                                          \
        }                                                                                                              \
      } else {                                                                                                         \
        return ns::formatter<T>::format( static_cast<const T&>( p ), ctx );                                            \
      }                                                                                                                \
    }                                                                                                                  \
  };
 
GAUDI_PROPERTY_FORMATTING_IMPL( fmt, static_assert( true ) )
 
#ifndef __cpp_lib_format_ranges
#  define assert_for_ranges                                                                                            \
    static_assert( !std::ranges::range<T> || std::is_same_v<T, std::string>,                                           \
                   "Range-valued Property formatting is not supported with std::format in C++20" )
#else
#  define assert_for_ranges static_assert( true )
#endif
 
GAUDI_PROPERTY_FORMATTING_IMPL( std, assert_for_ranges )
 
#undef assert_for_ranges
#undef GAUDI_PROPERTY_FORMATTING_IMPL