format-string.hpp

Go to the documentation of this file.

/*
  FORMAT-STRING.hpp  -  string template formatting based on boost::format

  Copyright (C)         Lumiera.org
    2011,               Hermann Vosseler <Ichthyostega@web.de>

  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of
  the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef UTIL_FORMAT_STRING_H
#define UTIL_FORMAT_STRING_H

#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/nocopy.hpp"
#include "lib/meta/util.hpp"
#include "lib/meta/size-trait.hpp"

#include <string>



namespace std {// forward declaration to avoid including <iostream>
  
  template<typename C>
  struct char_traits;
  
  template<typename C, class _TRAITS>
  class basic_ostream;
  
  using ostream = basic_ostream<char, char_traits<char>>;
}


namespace lib {
  class Literal;
  class Symbol;
}


namespace util {
  
  using std::string;
  
  typedef unsigned char uchar;

  LUMIERA_ERROR_DECLARE (FORMAT_SYNTAX); 
  
  
  
  class _Fmt
    : util::NonCopyable
    {
      enum{ FORMATTER_SIZE = lib::meta::SizeTrait::BOOST_FORMAT };
      
      typedef std::byte Implementation[FORMATTER_SIZE];
      
      
      alignas(size_t) mutable Implementation formatter_;
      
      
      template<typename VAL>
      static void format (const VAL, Implementation&);
      
      template<typename VAL, class SEL =void>
      struct Converter;
      
      
      
    public:
     ~_Fmt ();
      _Fmt (string formatString);
      
      operator string()  const;  
      
      template<typename VAL>
      _Fmt&
      operator% (VAL const&);
      
      
      friend std::ostream&
      operator<< (std::ostream& os, _Fmt const&);
      
      friend bool operator== (_Fmt const&,        _Fmt const&);
      friend bool operator== (_Fmt const&,      string const&);
      friend bool operator== (_Fmt const&, const char * const);
      friend bool operator== (string const&     , _Fmt const&);
      friend bool operator== (const char * const, _Fmt const&);
      
      template<typename X>
      friend bool operator != (_Fmt const& fmt, X const& x) { return not (fmt == x); }
      template<typename X>
      friend bool operator != (X const& x, _Fmt const& fmt) { return not (x == fmt); }
    };
  
  
  
  
  
  /* ===== forwarding into the implementation ====== */
  
  template<typename VAL>
  inline _Fmt&
  _Fmt::operator% (VAL const& val)
  {
    Converter<VAL>::dump (val, formatter_);
    return *this;
  }
  
  
  
  namespace { // helpers to pick a suitable specialisation....
    
    using std::__and_;
    using std::__not_;
    
    template<typename X>
    struct _allow_call : std::false_type {};
    
    /* the following definitions enable some primitive types
     * to be handed over to the boost::format implementation */
    template<> struct _allow_call<string>  : std::true_type { };
    template<> struct _allow_call<char>    : std::true_type { };
    template<> struct _allow_call<uchar>   : std::true_type { };
    template<> struct _allow_call<int16_t> : std::true_type { };
    template<> struct _allow_call<uint16_t>: std::true_type { };
    template<> struct _allow_call<int32_t> : std::true_type { };
    template<> struct _allow_call<uint32_t>: std::true_type { };
    template<> struct _allow_call<int64_t> : std::true_type { };
    template<> struct _allow_call<uint64_t>: std::true_type { };
    template<> struct _allow_call<float>   : std::true_type { };
    template<> struct _allow_call<double>  : std::true_type { };
#ifndef __x86_64__
    template<> struct _allow_call<long>    : std::true_type { };
    template<> struct _allow_call<ulong>   : std::true_type { };
#endif
    
    template<typename X>
    struct _shall_format_directly
      : _allow_call<std::remove_cv_t<X>>
      { };
    
    template<typename X>
    struct _shall_convert_toString
      : __and_<__not_<_shall_format_directly<X>>
              , std::bool_constant<lib::meta::can_convertToString<X>::value>
              >
      { };
    
    
    template<typename SP>
    struct _is_smart_wrapper
      : std::false_type
      { };
    template<typename T>
    struct _is_smart_wrapper<std::shared_ptr<T>>
      : std::true_type
      { };
    template <typename T, typename D>
    struct _is_smart_wrapper<std::unique_ptr<T,D>>
      : std::true_type
      { };
    
    
    
    template<typename SP>
    struct _shall_show_smartWrapper
      : __and_<__not_<_shall_convert_toString<SP>>
              ,_is_smart_wrapper<std::remove_reference_t<std::remove_cv_t<SP>>>
              >
      { };
    
    
    
    
    
    inline void
    _clear_errorflag()
    {
      const char* errID = lumiera_error();
      TRACE_IF (errID, progress, "Lumiera errorstate '%s' cleared.", errID);
    }
    
    inline string
    _log_and_stringify (std::exception const& ex)
    {
      _clear_errorflag();
      WARN (progress, "Error while invoking custom string conversion: %s", ex.what());
      try {
          return string("<string conversion failed: ")+ex.what()+">";
        }
      catch(...) { /* secondary errors ignored */ }
      return "(formatting failure)";
    }
    
    inline string
    _log_unknown_exception()
    {
      const char* errID = lumiera_error();
      if (errID)
        ERROR (progress, "Unknown error while invoking custom string conversion. Lumiera error flag = %s", errID);
      else
        ERROR (progress, "Unknown error while invoking custom string conversion. No Lumiera error flag set.");
      return "<Unknown error in string conversion>";
    }
    
  }//(End) guards/helpers
  
  
  
  
  /* === explicit specialisations to control the kind of conversion === */
  
  template<typename VAL, class SEL>
  struct _Fmt::Converter
    {
      static void
      dump (VAL const&, Implementation& impl)
        {
          format ("«"+typeStr<VAL>()+"»", impl);
        }
    };
  
  template<typename VAL>
  struct _Fmt::Converter<VAL*>
    {
      static void
      dump (const VAL *pVal, Implementation& impl)
        {
          if (pVal)
            Converter<VAL>::dump(*pVal, impl);
          else
            format (BOTTOM_INDICATOR, impl);
        }
    };
  
  template<>
  struct _Fmt::Converter<void *>
    {
      static void
      dump (const void* address, Implementation& impl)
        {
          format (address, impl);
        }
    };
  
  template<>
  struct _Fmt::Converter<const char *>
    {
      static void
      dump (const char* cString, Implementation& impl)
        {
          format (cString? cString : BOTTOM_INDICATOR, impl);
        }
    };
  
  template<>
  struct _Fmt::Converter<bool>
    {
      static void
      dump (bool yes, Implementation& impl)
        {
          format (yes? "true":"false", impl);
        }
    };
  
  template<>
  struct _Fmt::Converter<lib::Literal>
    {
      static void
      dump (lib::Literal const& literal, Implementation& impl)
        {
          format (literal.empty()? "" : literal.c(), impl);
        }
    };
  
  template<>
  struct _Fmt::Converter<lib::Symbol>
    {
      static void
      dump (lib::Symbol const& symbol, Implementation& impl)
        {
          format (symbol.c(), impl);
        }
    };
  
  template<typename VAL>
  struct _Fmt::Converter<VAL,      lib::meta::enable_if<_shall_convert_toString<VAL>> >
    {
      static void
      dump (VAL const& val, Implementation& impl)
        try {
            format (string(val), impl);
          }
        catch(std::exception const& ex)
          {
            format (_log_and_stringify(ex), impl);
          }
        catch(...)
          {
            format (_log_unknown_exception(), impl);
          }
    };
  
  template<typename SP>
  struct _Fmt::Converter<SP,       lib::meta::enable_if<_shall_show_smartWrapper<SP>> >
    {
      static void
      dump (SP const& smP, Implementation& impl)
        try {
            format (showSmartPtr (smP, lib::meta::typeSymbol(smP)), impl);
          }
        catch(std::exception const& ex)
          {
            format (_log_and_stringify(ex), impl);
          }
        catch(...)
          {
            format (_log_unknown_exception(), impl);
          }
    };
  
  template<typename VAL>
  struct _Fmt::Converter<VAL,      lib::meta::enable_if<_shall_format_directly<VAL>> >
    {
      static void
      dump (const VAL val, Implementation& impl)
        {
          format (val, impl);
        }
    };
  
  
  
  /* === comparison of formatter objects === */
  
  inline bool
  operator== (_Fmt const& left, _Fmt const& right)
  {
    return string(left) == string(right);
  }
  
  inline bool
  operator== (_Fmt const& fmt, string const& str)
  {
    return string(fmt) == str;
  }
  
  inline bool
  operator== (_Fmt const& fmt, const char * const cString)
  {
    return string(fmt) == string(cString);
  }
  
  inline bool
  operator== (string const& str, _Fmt const& fmt)
  {
    return fmt == str;
  }
  
  inline bool
  operator== (const char * const cString, _Fmt const& fmt)
  {
    return fmt == cString;
  }
  
  
  
} // namespace util
#endif