format-string.cpp

Go to the documentation of this file.

/*
  FormatString  -  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.

* *****************************************************/

#include "lib/error.hpp"
#include "lib/format-util.hpp"
#include "lib/format-string.hpp"

#include <boost/static_assert.hpp>
#include <boost/format.hpp>
#include <iostream>
#include <cstddef>
#include <new>





namespace util {
  
  using boost::format;
  
  
  namespace { // implementation details...
    
    inline boost::format&
    accessImpl (std::byte* buffer)
    {
      return * std::launder (reinterpret_cast<boost::format*> (buffer));
    }
    
    
    inline void
    destroyImpl (std::byte* buffer)
    {
      accessImpl(buffer).~format();
    }
    
    
    void
    pushFailsafeReplacement (std::byte* formatter, const char* errorMsg =NULL)
    try {
        string placeholder("<Error");
        if (errorMsg){
            placeholder += ": ";
            placeholder += errorMsg;
        }
        placeholder += ">";
        
        accessImpl(formatter) % placeholder;
      }
    ERROR_LOG_AND_IGNORE (progress, "Supplying placeholder for problematic format parameter")
    
    
    inline void
    suppressInsufficientArgumentErrors (std::byte* formatter)
    {
      using namespace boost::io;
      accessImpl(formatter).exceptions (all_error_bits ^ too_few_args_bit);
    }
    
    
  }//(End) implementation details
  
  
  
  
  
  _Fmt::_Fmt (string formatString)
  try {
      static_assert (sizeof(boost::format) <= FORMATTER_SIZE,
                     "opaque working buffer insufficient "
                     "to hold a boost::format instance. "
                     "Maybe boost implementation change. "
                     "Please verify lib/meta/size-trait.hpp");
      
      new(formatter_) boost::format(formatString);
      suppressInsufficientArgumentErrors (formatter_);
    }
  catch (boost::io::bad_format_string& syntaxError)
    {
      throw lumiera::error::Fatal (syntaxError
                                  , _Fmt("Format string '%s' is broken") % formatString
                                  , LUMIERA_ERROR_FORMAT_SYNTAX);
    }
  
  
  _Fmt::~_Fmt ()
  {
    destroyImpl (formatter_);
  }
  
  
  template<typename VAL>
  void
  _Fmt::format (const VAL val, Implementation& formatter)
  try {
      accessImpl(formatter) % val;
    }
  
  catch (boost::io::too_many_args& argErr)
    {
      WARN (progress, "Format: excess argument '%s' of type «%s» ignored."
                    , cStr(toString(val))
                    , cStr(typeStr(val)));
    }
  catch (std::exception& failure)
    {
      _clear_errorflag();
      WARN (progress, "Format: Parameter '%s' causes problems: %s"
                    , cStr(toString(val))
                    , failure.what());
      pushFailsafeReplacement (formatter, failure.what());
    }
  catch (...)
    {
      _clear_errorflag();
      WARN (progress, "Format: Unexpected problems accepting format parameter '%s'", cStr(toString(val)));
      pushFailsafeReplacement (formatter);
    }
  
  
  
  
  /* ===== explicitly supported =================== */
  
  template void _Fmt::format (const char,    Implementation&);
  template void _Fmt::format (const uchar,   Implementation&);
  template void _Fmt::format (const int16_t, Implementation&);
  template void _Fmt::format (const uint16_t,Implementation&);
  template void _Fmt::format (const int32_t, Implementation&);
  template void _Fmt::format (const uint32_t,Implementation&);
  template void _Fmt::format (const int64_t, Implementation&);
  template void _Fmt::format (const uint64_t,Implementation&);
  template void _Fmt::format (const float,   Implementation&);
  template void _Fmt::format (const double,  Implementation&);
  template void _Fmt::format (const string,  Implementation&);
  template void _Fmt::format (const void *,  Implementation&);
  template void _Fmt::format (const char *,  Implementation&);
#ifndef __x86_64__
  template void _Fmt::format (const long,    Implementation&);
  template void _Fmt::format (const ulong,   Implementation&);
#endif
  
  
  
  
  _Fmt::operator string()  const
  try {
      return accessImpl(formatter_).str();
    }
  
  catch (std::exception& failure)
    {
      _clear_errorflag();
      WARN (progress, "Format: Failure to receive formatted result: %s", failure.what());
      return "<formatting failure>";
    }
  catch (...)
    {
      _clear_errorflag();
      WARN (progress, "Format: Unexpected problems while formatting output.");
      return "<unexpected problems>";
    }
  
  
  
  std::ostream&
  operator<< (std::ostream& os, _Fmt const& fmt)
  try {
      return os << accessImpl(fmt.formatter_);
    }
  
  catch(std::exception& failure)
    {
      _clear_errorflag();
      WARN (progress, "Format: Failure when outputting formatted result: %s", failure.what());
      return os << "<formatting failure>";
    }
  catch(...)
    {
      _clear_errorflag();
      WARN (progress, "Format: Unexpected problems while producing formatted output.");
      return os << "<unexpected problems>";
    }
  
  
  LUMIERA_ERROR_DEFINE (FORMAT_SYNTAX, "Syntax error in format string for boost::format");
  
  
  
} // namespace util