ostream_helpers.h

Go to the documentation of this file.

#ifndef fhiclcpp_types_detail_ostream_helpers_h
#define fhiclcpp_types_detail_ostream_helpers_h

#include "cetlib_except/demangle.h"

#include <ostream>
#include <string>
#include <typeinfo>

namespace fhicl::detail::yes_defaults {

  //=================================================================
  // std::string
  //
  // When printing out strings, it is best to surround them with
  // \"...\" so that there will be no ambiguity for the user.
  template <typename T>
  struct maybe_quotes {
    maybe_quotes(T const& t) : value(t) {}
    T const& value;
  };

  template <>
  struct maybe_quotes<std::string> {
    maybe_quotes(std::string const& t) : value{"\"" + t + "\""} {}
    std::string value;
  };

  inline std::ostream&
  operator<<(std::ostream& os, maybe_quotes<bool>&& mq)
  {
    return os << std::boolalpha << mq.value;
  }

  template <typename T>
  inline std::ostream&
  operator<<(std::ostream& os, maybe_quotes<T>&& mq)
  {
    if constexpr (std::is_floating_point_v<T>) {
      return os << std::showpoint << mq.value;
    } else {
      return os << mq.value;
    }
  }
} // fhicl::detail::yes_defaults

//====================================================================================
//                                                                                   =
//====================================================================================

namespace fhicl::detail::no_defaults {

  std::string stripped_typename(std::string const& fullName);

  inline std::string
  padded_string(std::string const& tnToPad)
  {
    return std::string("<") + tnToPad + std::string(">");
  }

  inline std::string
  presented_string(std::string const& fullName)
  {
    return padded_string(stripped_typename(fullName));
  }

  template <typename T>
  struct expected_types {
    expected_types() : value("")
    {
      std::string const strippedTypename =
        stripped_typename(cet::demangle_symbol(typeid(T).name()));
      value = padded_string(strippedTypename);
    }
    std::string value;
  };

  // std::string is an expected_type but may be demangled to full
  // typename when inline namespaces are used (libc++, gcc5)
  // Specialize expected_types for this type
  template <>
  struct expected_types<std::string> {
    expected_types() : value("std::string")
    {
      value = padded_string(stripped_typename(value));
    }
    std::string value;
  };

  template <typename T>
  std::ostream&
  operator<<(std::ostream& os, expected_types<T>&& et)
  {
    return os << et.value;
  }
} // fhicl::detail::no_defaults

#endif /* fhiclcpp_types_detail_ostream_helpers_h */

// Local variables:
// mode : c++
// End: