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 <utility> // std::forward()
#include <type_traits> // std::is_same<>
#include <cstdio> // std::snprintf()
#include <iosfwd> // std::ostream


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