hexfloat.h

Go to the documentation of this file.

#ifndef LARDATA_RECOBASEART_DUMPERS_HEXFLOAT_H
#define LARDATA_RECOBASEART_DUMPERS_HEXFLOAT_H 1

// C/C++ standard libraries
#include <cstdio>      // std::snprintf()
#include <iosfwd>      // std::ostream
#include <type_traits> // std::is_same<>
#include <utility>     // std::forward()

namespace lar {

  namespace details {

    template <typename T>
    struct OptionalHexFloatFormatter {
    public:
      using real_t = T;

      // sprintf() does not support floats;
      // it will probably do some bad thing with them
      static_assert(!std::is_same<std::decay_t<T>, float>::value,
                    "OptionalHexFloatFormatter does not support float values");

      OptionalHexFloatFormatter(real_t v, bool start_active = true) : active(start_active), value(v)
      {}

      template <typename Stream>
      Stream& operator()(Stream&& os) const
      {
        write(std::forward<Stream>(os), value);
        return os;
      }

      template <typename Stream>
      void write(Stream&& os, real_t v) const
      {
        if (active)
          write_hexfloat(std::forward<Stream>(os), v);
        else
          write_standard(std::forward<Stream>(os), v);
      }

      template <typename Stream>
      static void write_hexfloat(Stream&& os, real_t v)
      {
        constexpr auto buf_size = 8 * sizeof(real_t) + 1;
        char buf[buf_size];
        std::snprintf(buf, buf_size, "%+24.14a", v);
        os << buf;
      }

      template <typename Stream>
      static void write_standard(Stream&& os, real_t v)
      {
        os << v;
      }

    private:
      bool active;  
      real_t value; 

    }; // OptionalHexFloatFormatter

    template <typename T>
    std::ostream& operator<<(std::ostream& os, details::OptionalHexFloatFormatter<T> fmt)
    {
      return fmt(os);
    }

  } // namespace details

  class OptionalHexFloat {

  public:
    OptionalHexFloat(bool start_active = true) : active(start_active) {}

    bool enabled() const { return active; }

    void enable(bool enable = true) { active = enable; }

    void disable() { active = false; }

    template <typename T>
    auto operator()(T value) const
    {
      return formatter_t<T>(value, active);
    }

    template <typename T>
    auto operator()(bool this_active, T value) const
    {
      return formatter_t<T>(this_active, value);
    }

  private:
    template <typename T>
    using formatter_t = details::OptionalHexFloatFormatter<T>;

    bool active; 

  }; // OptionalHexFloat

} // namespace lar

#endif // LARDATA_RECOBASEART_DUMPERS_HEXFLOAT_H