duck-detector.hpp

Go to the documentation of this file.

/*
  DUCK-DETECTOR.hpp  -  helpers for statically detecting properties of a type
 
   Copyright (C)
     2010,            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_DUCK_DETECTOR_H
#define LIB_META_DUCK_DETECTOR_H
 
 
#include "lib/meta/util.hpp"
 
 
 
 
 
#define META_DETECT_NESTED(_TYPE_)                            \
    template<typename TY>                                      \
    class HasNested_##_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))); \
      };
 
 
 
#define META_DETECT_MEMBER(_NAME_)                         \
    template<typename TY>                                   \
    class HasMember_##_NAME_                                 \
      {                                                       \
        template<typename X,                                   \
                 typename SEL = decltype(&X::_NAME_)>           \
        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<TY>(0)));  \
      };
 
 
 
#define META_DETECT_FUNCTION(_RET_TYPE_,_FUN_NAME_,_ARGS_) \
    template<typename TY>                                   \
    class HasFunSig_##_FUN_NAME_                             \
      {                                                       \
        template<typename X, _RET_TYPE_ (X::*)_ARGS_>          \
        struct Probe                                            \
          { };                                                   \
                                                                  \
        template<class X>                                          \
        static Yes_t check(Probe<X, &X::_FUN_NAME_> * );            \
        template<class>                                              \
        static No_t  check(...);                                      \
                                                                       \
      public:                                                           \
        static const bool value = (sizeof(Yes_t)==sizeof(check<TY>(0))); \
      };
 
 
#define META_DETECT_FUNCTION_NAME(_FUN_NAME_)            \
    template<typename TY>                                 \
    class HasFunName_##_FUN_NAME_                          \
      {                                                     \
        template<typename SEL>                               \
        struct Probe;                                         \
        template<class C, typename RET, typename...ARGS>       \
        struct Probe<RET (C::*) (ARGS...)>                      \
          {                                                      \
            using Match = void;                                   \
          };                                                       \
        template<class C, typename RET, typename...ARGS>            \
        struct Probe<RET (C::*) (ARGS...)  const>                    \
          {                                                           \
            using Match = void;                                        \
          };                                                            \
                                                                         \
        template<class X>                                                 \
        static Yes_t check(Probe<decltype(&X::_FUN_NAME_)>::Match * );     \
        template<class>                                                     \
        static No_t  check(...);                                             \
                                                                              \
      public:                                                                  \
        static const bool value = (sizeof(Yes_t)==sizeof(check<TY>(0)));        \
      };
 
 
#define META_DETECT_FUNCTION_ARGLESS(_FUN_)                    \
    template<typename TY>                                       \
    class HasArglessFun_##_FUN_                                  \
      {                                                           \
        template<typename X,                                       \
                 typename SEL = decltype(std::declval<X>()._FUN_())>\
        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<TY>(0)));      \
      };
 
 
 
#define META_DETECT_EXTENSION_POINT(_FUN_)                     \
    template<typename TY>                                       \
    class HasExtensionPoint_##_FUN_                              \
      {                                                           \
        template<typename X,                                       \
                 typename SEL = decltype( _FUN_(std::declval<X>()))>\
        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<TY>(0)));      \
      };
 
 
 
#define META_DETECT_OPERATOR_DEREF()                       \
    template<typename TY>                                   \
    class HasOperator_deref                                  \
      {                                                       \
        template<typename X, int i = sizeof(&X::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<TY>(0))); \
      };
 
 
 
#define META_DETECT_OPERATOR_INC()                    \
    template<typename TY>                              \
    class HasOperator_inc                               \
      {                                                  \
        template<typename X, X& (X::*)(void)>             \
        struct Probe_1                                     \
          { };                                              \
        template<typename X, int i = sizeof(&X::operator++)> \
        struct Probe_2                                        \
          { };                                                 \
                                                                \
        template<class X>                                        \
        static Yes_t check1(Probe_1<X, &X::operator++> * );       \
        template<class>                                            \
        static No_t  check1(...);                                   \
        template<class X>                                            \
        static Yes_t check2(Probe_2<X> * );                           \
        template<class>                                                \
        static No_t  check2(...);                                       \
                                                                         \
      public:                                                             \
        static const bool value = (sizeof(Yes_t)==sizeof(check1<TY>(0))    \
                                or sizeof(Yes_t)==sizeof(check2<TY>(0)));   \
      };
 
 
 
#endif