meta/util.hpp

Go to the documentation of this file.

/*
  UTIL.hpp  -  metaprogramming helpers and utilities

  Copyright (C)         Lumiera.org
    2008,               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_META_UTIL_H
#define LIB_META_UTIL_H

#include "lib/integral.hpp"

#include <typeinfo>
#include <string>

namespace std {
  
  // forward declarations for common smart ptrs
  template<typename T>
  class shared_ptr;
  
  template <typename T, typename D>
  class unique_ptr;
  
}



namespace lib {
  class Literal;
  class Symbol;
  
namespace meta {
  
  /* === conditional definition selector === */
  
  template <bool B, class T = void>
  struct enable_if_c {
    typedef T type;
  };

  template <class T>
  struct enable_if_c<false, T> {};
  
  
  template <class Cond, class T = void>
  using enable_if = typename enable_if_c<Cond::value, T>::type;
  
  template <class Cond, class T = void>
  using disable_if = typename enable_if_c<not Cond::value, T>::type;
  
  
  
  
  /* === building metafunctions === */
  
  typedef char Yes_t;
  struct No_t { char more_than_one[4]; };
  
  
  
  
  namespace {
    template<typename TY>
    class _DetectNested_TypeResult
      {
        template<class ZZ>
        static Yes_t check(typename ZZ::type *);
        template<class X>
        static Yes_t check(typename X::Type *);
        template<class>
        static No_t  check(...);
        
      public:
        static const bool value = (sizeof(Yes_t)==sizeof(check<TY>(0)));
      };
    
  }
  template<typename X>
  struct has_TypeResult : std::bool_constant<_DetectNested_TypeResult<X>::value> { };
  
  
  
  namespace {
    template<typename...>
    struct _ExtractFirst
      {
        using Type = void;
      };
    template<typename X, typename...XS>
    struct _ExtractFirst<X,XS...>
      {
        using Type = X;
      };
  }
  template<typename...XS>
  using extractFirst_t = typename _ExtractFirst<XS...>::Type;
  
  
  
  template<class SELF, typename ...ARGS>
  using disable_if_self = disable_if<std::is_same<std::remove_cv_t<std::remove_reference_t<extractFirst_t<ARGS...>>>
                                                 , SELF>>;
  
  
  
  template<typename X>
  struct can_convertToString
    {
      
      static Yes_t check_implicit(std::string);
      static Yes_t check_implicit(std::string_view);
      static Yes_t check_implicit(const char*);
      static No_t  check_implicit(...);
      
      
      template<class XX, int i = sizeof(&XX::operator std::string)>
      struct Probe
      { };
      
      template <class XX>
      static Yes_t check_explicit(Probe<XX> * );
      template <class>
      static No_t  check_explicit(...);
      
    public:
      static const bool value = (sizeof(Yes_t)==sizeof(check_implicit (std::declval<X>())))
                             or (sizeof(Yes_t)==sizeof(check_explicit<X>(0)));
    };
  
  template<typename X>
  using enable_CustomStringConversion = enable_if<can_convertToString<X>>;
  
  
  
  
  template<typename TY>
  class is_Typelist
    {
      template<class X>
      static Yes_t check(typename X::List *);
      template<class>
      static No_t  check(...);
      
    public:
      static const bool value = (sizeof(Yes_t)==sizeof(check<TY>(0)));
    };
  
  
  template<typename FUN>
  class has_FunctionOperator
    {
      template<typename FF,
               typename SEL = decltype(&FF::operator())>
      struct Probe
        { };
      
      template<class X>
      static Yes_t check(Probe<X> * );
      template<class>
      static No_t  check(...);
      
    public:
      static const bool value = (sizeof(Yes_t)==sizeof(check<FUN>(0)));
    };
  
  
  template<class BAS, size_t m=0>
  struct Marked
    : BAS
    {
      using BAS::BAS;
    };
  
  
  
  
  
  
  
  
  /* ==== generic string representation ==== */
  
  std::string humanReadableTypeID (lib::Literal);
  
  std::string primaryTypeComponent (lib::Literal);
  
  std::string sanitisedFullTypeName(lib::Literal);
  
  std::string sanitisedSymbol(std::string const&);
  
  std::string demangleCxx (lib::Literal rawName);
  
  
  extern const std::string FUNCTION_INDICATOR;
  extern const std::string FAILURE_INDICATOR;
  extern const std::string BOTTOM_INDICATOR;
  extern const std::string VOID_INDICATOR;
  
  extern const std::string BOOL_FALSE_STR;
  extern const std::string BOOL_TRUE_STR;
  
  
  template<typename TY>
  inline std::string
  typeStr (TY const* obj =nullptr)  noexcept
    try {
      auto mangledType = obj? typeid(*obj).name()
                            : typeid(TY).name();
      return humanReadableTypeID (mangledType);
    }
    catch(...)
    { return FAILURE_INDICATOR; }
  
  template<typename TY>
  inline                   disable_if<std::is_pointer<TY>,
  std::string              >
  typeStr (TY const& ref)  noexcept
  {
    return typeStr (&ref);
  }
  
  inline std::string
  typeStr (void const*)  noexcept
  {
    return VOID_INDICATOR;
  }
  
  
  
  
  template<typename TY>
  inline std::string
  typeSymbol (TY const* obj =nullptr)
  {
    auto mangledType = obj? typeid(*obj).name()
                          : typeid(TY).name();
    return primaryTypeComponent (mangledType);
  }
  
  template<typename TY>
  inline                   disable_if<std::is_pointer<TY>,
  std::string              >
  typeSymbol (TY const& ref)
  {
    return typeSymbol (&ref);
  }
  
}}// namespace lib::meta




namespace util {
  
  using lib::meta::typeStr;
  using lib::meta::FAILURE_INDICATOR;
  using lib::meta::BOTTOM_INDICATOR;
  
  
  template<typename X, typename COND =void>
  struct StringConv
    {
      static std::string
      invoke (X const& x)  noexcept
        try        { return "«"+typeStr(x)+"»"; }
        catch(...) { return FAILURE_INDICATOR; }
    };
  
  template<typename X>
  struct StringConv<X,     lib::meta::enable_CustomStringConversion<X>>
    {
      static std::string
      invoke (X const& val) noexcept
        try        { return std::string(val); }
        catch(...) { return FAILURE_INDICATOR; }
    };
  
  template<typename X>
  struct StringConv<X*,      lib::meta::disable_if<std::__or_<std::is_same<std::remove_cv_t<X>, char>
                                                             ,std::is_same<std::remove_cv_t<X>, void>
                                                             > >>
    {
      static std::string
      invoke (X const* ptr) noexcept
        try        { return ptr? "↗" + StringConv<X>::invoke(*ptr)
                               : BOTTOM_INDICATOR + "«"+typeStr(ptr)+"»";
                   }
        catch(...) { return FAILURE_INDICATOR; }
    };
  
  // NOTE: this is meant to be extensible;
  //       more specialisations are e.g. in format-obj.hpp
  
  
  
  
  inline std::string
  showBool (bool yes)  noexcept
  {
    return yes? lib::meta::BOOL_TRUE_STR
              : lib::meta::BOOL_FALSE_STR;
  }
  
  std::string showDouble (double) noexcept;
  std::string showFloat (float)   noexcept;
  
  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;
  
  std::string showSize (size_t)   noexcept;
  
  
  
  std::string showAddr (void const* addr) noexcept;
  
  template<typename X>
  inline std::string
  showAddr (X& elm)  noexcept
  {
    return showAddr(&elm);
  }
  
  
  template<typename X>
  inline std::string
  showPtr (X* ptr =nullptr)
  {
    return ptr? showAddr(ptr) + " ↗" + StringConv<X>::invoke(*ptr)
              : BOTTOM_INDICATOR + " «" + typeStr(ptr) + "»";
  }
  
  template<typename SP>
  inline std::string
  showSmartPtr (SP const& smPtr, std::string label = "smP")
  {
    using TargetType = typename SP::element_type;
    
    return smPtr? label+"("+showAddr(smPtr.get()) + ") ↗" + StringConv<TargetType>::invoke(*smPtr)
                : BOTTOM_INDICATOR + " «" + typeStr(smPtr) + "»";
  }
  
  
}// namespace util



/* === Literals for common size designations === */

inline uint
operator""_KiB (unsigned long long const siz)
{
  return uint(siz) * 1024u;
}

inline uint
operator""_MiB (unsigned long long const siz)
{
  return uint(siz) * 1024u*1024u;
}

inline unsigned long long
operator""_GiB (unsigned long long const siz)
{
  return siz * 1024uLL*1024uLL*1024uLL;
}


#endif /*LIB_META_UTIL_H*/