Format.hpp

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_COMMON_FORMAT_HPP_
#define GEOS_COMMON_FORMAT_HPP_
 
#include <type_traits>
#include <optional>
#include <sstream>
#include <string>
 
#define GEOS_USE_FMT
 
#ifdef GEOS_USE_FMT
#ifndef FMT_HEADER_ONLY
#define FMT_HEADER_ONLY
#endif
// Differentiate between standalone fmt path and umpire's fmt path
#include "../include/fmt/core.h"
#include "../include/fmt/chrono.h"
#include "../include/fmt/ranges.h"
#include "../include/fmt/xchar.h"
#define GEOS_FMT_NS fmt
#endif
 
#ifdef GEOS_USE_FMT
template< typename T >
struct fmt::formatter< T, std::enable_if_t< std::is_enum< T >::value > >
{
  template< typename ParseContext >
  constexpr auto parse( ParseContext & ctx )
  {
    return ctx.end();
  }
 
  template< typename FormatContext >
  auto format( const T & value, FormatContext & ctx ) const
  {
    return fmt::format_to( ctx.out(), "{}", static_cast< std::underlying_type_t< T > >( value ) );
  }
};
#endif
 
#define GEOS_FMT( msg, ... ) GEOS_FMT_NS::format( msg, __VA_ARGS__ )
 
#define GEOS_FMT_RUNTIME( msg, ... ) GEOS_FMT_NS::format( GEOS_FMT_NS::runtime( msg ), __VA_ARGS__ )
 
#define GEOS_FMT_TO( iter, size, msg, ... ) *GEOS_FMT_NS::format_to_n( iter, size - 1, msg, __VA_ARGS__ ).out = '\0'
 
 
template< typename T >
struct GEOS_FMT_NS::formatter< std::optional< T > > : GEOS_FMT_NS::formatter< T >
{
  auto format( std::optional< T > const & opt, format_context & ctx ) const
  {
    if( opt )
    {
      return GEOS_FMT_NS::formatter< T >::format( *opt, ctx );
    }
    return GEOS_FMT_NS::format_to( ctx.out(), "" );
  }
};
 
 
// The following workaround is needed to fix compilation with NVCC on some PowerPC machines.
// The issue causes the following assertion error message:
// "Cannot format an argument. To make type T formattable provide a formatter<T> specialization"
// The standard definition of the has_const_formatter check of fmt fails due to a compiler bug, see the issue below:
// https://github.com/fmtlib/fmt/issues/2746
// The workaround was originally implemented in fmt:
// https://github.com/fmtlib/fmt/commit/70de324aa801eaf52e94c402d526a3849797c620
// but later removed:
// https://github.com/fmtlib/fmt/commit/466e0650ec2d153d255a40ec230eb77d7f1c3334
// This workaround bypasse the check for a const formatter whenever the foramt context GEOS_FMT_NS::format_context is used
#ifdef GEOS_USE_FMT_CONST_FORMATTER_WORKAROUND
template< >
constexpr auto GEOS_FMT_NS::detail::has_const_formatter_impl< GEOS_FMT_NS::format_context >( ... ) -> bool
{
  return true;
}
#endif // End of the workaround for fmt compilation issues
 
template< class T >
static constexpr bool has_formatter_v = fmt::is_formattable< fmt::remove_cvref_t< T > >::value;
 
namespace geos::format
{
 
template< class T >
inline std::string toStringForFmt( T const & v )
{
  if constexpr ( std::is_convertible_v< T, std::string > )
  {
    return std::string( v );
  }
  else if constexpr ( std::is_convertible_v< T, std::string_view > )
  {
    return std::string( std::string_view( v ) );
  }
  else
  {
    std::ostringstream os;
    os << v;              // requires operator<<(ostream&, T)
    return os.str();
  }
}
 
} // namespace geos::format
 
#endif //GEOS_COMMON_FORMAT_HPP_