format-obj.hpp

Go to the documentation of this file.

/*
  FORMAT-OBJ.hpp  -  simple means to display an object

  Copyright (C)         Lumiera.org
    2016,               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 LIB_FORMAT_OBJ_H
#define LIB_FORMAT_OBJ_H

#include "lib/symbol.hpp"
#include "lib/meta/trait.hpp"

#include <boost/lexical_cast.hpp>


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;
  
namespace meta {
  
  std::string demangleCxx (lib::Literal rawName);
  std::string humanReadableTypeID (lib::Literal);
  std::string primaryTypeComponent (lib::Literal);
  std::string sanitisedFullTypeName(lib::Literal);
  
}}// namespace lib::meta






namespace util {
  
  std::string showDouble (double) noexcept;
  std::string showFloat (float)   noexcept;
  std::string showSize (size_t)   noexcept;
  std::string showAddr (void const* addr) noexcept;
  
  std::ostream& showAddr (std::ostream&, void const* addr);
  
  std::string showHash   (size_t hash, uint showBytes=8)  noexcept;
  
  inline std::string
  showHashLSB (size_t hash)  noexcept
  {
    return showHash(hash,1);
  }
  
  std::string showDecimal (double) noexcept;
  std::string showDecimal (float)  noexcept;
  std::string showDecimal (f128)   noexcept;
  std::string showComplete (double)noexcept;
  std::string showComplete (float) noexcept;
  std::string showComplete (f128)  noexcept;
  
  
  
  namespace {
    template<typename X>
    using enable_LexicalConversion = lib::meta::enable_if< lib::meta::use_LexicalConversion<X>>;
    
    template<typename SP>
    using show_SmartPointer = lib::meta::enable_if< lib::meta::is_smart_ptr<typename lib::meta::Strip<SP>::TypeReferred>>;
  }
  
  
  
  /* === generalise the failsafe string conversion === */
  
  template<typename X>
  struct StringConv<X,     enable_LexicalConversion<X>>
    {
      static std::string
      invoke (X const& val) noexcept
        try        { return boost::lexical_cast<std::string> (val); }
        catch(...) { return FAILURE_INDICATOR; }
    };
  
  template<typename SP>
  struct StringConv<SP,    show_SmartPointer<SP>>
    {
      static std::string
      invoke (SP const& smP) noexcept
        try        { return showSmartPtr (smP, lib::meta::typeSymbol(smP)); }
        catch(...) { return FAILURE_INDICATOR; }
    };
  
  template<>
  struct StringConv<double>
    {
      static std::string
      invoke (double val) noexcept
      {
        return util::showDouble (val);
      }
    };
  template<>
  struct StringConv<float>
    {
      static std::string
      invoke (float val) noexcept
      {
        return util::showFloat (val);
      }
    };
  template<>
  struct StringConv<bool>
    {
      static std::string
      invoke (bool val) noexcept
      {
        return util::showBool (val);
      }
    };
  
  
  
  
  template<typename TY>
  inline std::string
  toString (TY const& val)  noexcept
  {
    using PlainVal = typename lib::meta::Strip<TY>::TypeReferred;
    return StringConv<PlainVal>::invoke (val);
  }
  
  
  template<typename TY>
  inline std::string
  typedString (TY const& val)  noexcept
    try {
      std::string repr = StringConv<TY>::invoke (val);
      return 0 == repr.rfind("«", 0)? repr
                                    : "«"+typeStr(val)+"»|"+repr;
    }
    catch(...)
    { return FAILURE_INDICATOR; }
  
  
  
} // namespace util
#endif /*LIB_FORMAT_OBJ_H*/