meta/util.hpp

Go to the documentation of this file.

/*
  UTIL.hpp  -  metaprogramming helpers and utilities
 
   Copyright (C)
     2008,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** 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. See the file COPYING for further details.
 
*/
 
 
#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 {
  
  template<size_t siz>
  using SizConst = std::integral_constant<size_t, siz>;
  
  
  /* === 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 = enable_if_c<Cond::value, T>::type;
  
  template <class Cond, class T = void>
  using disable_if = 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(ZZ::type *);
        template<class X>
        static Yes_t check(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 = _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(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;
    };
  
  template<class BAS, typename TAG =void>
  struct Tagged
    : 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 showAdr (void const* addr) noexcept;
  
  template<typename X>
  inline                   lib::meta::disable_if<std::is_pointer<X>,
  std::string              >
  showAdr (X& elm)  noexcept
  {
    return showAdr(&elm);
  }
  
  
  template<typename X>
  inline std::string
  showPtr (X* ptr =nullptr)
  {
    return ptr? showAdr(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 = SP::element_type;
    
    return smPtr? label+"("+showAdr(smPtr.get()) + ") ↗" + StringConv<TargetType>::invoke(*smPtr)
                : BOTTOM_INDICATOR + " «" + typeStr(smPtr) + "»";
  }
  
  
}// namespace util
 
 
 
/* === Literals for common size designations === */
 
inline uint
operator""_KiB (ullong const siz)
{
  return uint(siz) * 1024u;
}
 
inline uint
operator""_MiB (ullong const siz)
{
  return uint(siz) * 1024u*1024u;
}
 
inline ullong
operator""_GiB (ullong const siz)
{
  return siz * 1024uLL*1024uLL*1024uLL;
}
 
 
#endif /*LIB_META_UTIL_H*/