access-casted-o.hpp

Go to the documentation of this file.

/*
  ACCESS-CASTED.hpp  -  util template to access a value using conversion or cast as appropriate
 
   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 UTIL_ACCESS_CASTED_O_H
#define UTIL_ACCESS_CASTED_O_H
 
#include <type_traits>
 
 
 
namespace util {
  
  namespace {
    using std::remove_pointer;
    using std::remove_reference;
    using std::is_convertible;
    using std::is_polymorphic;
    using std::is_base_of;
    
    
    template <typename SRC, typename TAR>
    struct can_cast : std::false_type {};
    
    template <typename SRC, typename TAR>
    struct can_cast<SRC*,TAR*>          { enum { value = is_base_of<SRC,TAR>::value };};
    
    template <typename SRC, typename TAR>
    struct can_cast<SRC*&,TAR*>         { enum { value = is_base_of<SRC,TAR>::value };};
    
    template <typename SRC, typename TAR>
    struct can_cast<SRC&,TAR&>          { enum { value = is_base_of<SRC,TAR>::value };};
    
    
    template <typename T>
    struct hasRTTI
      {
        typedef typename remove_pointer<
                typename remove_reference<T>::type>::type TPlain;
      
        enum { value = is_polymorphic<TPlain>::value };
      };
    
    template <typename SRC, typename TAR>
    struct use_dynamic_downcast
      {
        enum { value = can_cast<SRC,TAR>::value
                       &&  hasRTTI<SRC>::value
                       &&  hasRTTI<TAR>::value
             };
      };
    
    template <typename SRC, typename TAR>
    struct use_static_downcast
      {
        enum { value = can_cast<SRC,TAR>::value
                    && (  !hasRTTI<SRC>::value
                       || !hasRTTI<TAR>::value
                       )
             };
      };
    
    template <typename SRC, typename TAR>
    struct use_conversion
      {
        enum { value = is_convertible<SRC,TAR>::value
                    && !( use_static_downcast<SRC,TAR>::value
                        ||use_dynamic_downcast<SRC,TAR>::value
                        )
             };
      };
    
    
    
    template<typename X>
    struct EmptyVal
      {
        static X create()    { return X(); }
      };
    template<typename X>
    struct EmptyVal<X*&>
      {
        static X*& create()  { static X* nullP(0); return nullP; }
      };
    
  }
  
  
  
  
  template<typename RET>
  struct NullAccessor
    {
      typedef RET Ret;
      
      static RET access  (...) { return ifEmpty(); }
      static RET ifEmpty ()    { return EmptyVal<RET>::create(); }
    };
  
  template<typename TAR>
  struct AccessCasted_O : NullAccessor<TAR>
    {
      using NullAccessor<TAR>::access;
      
      template<typename ELM>
      static  typename std::enable_if< use_dynamic_downcast<ELM&,TAR>::value,
      TAR     >::type
      access (ELM& elem)
        {
          return dynamic_cast<TAR> (elem);
        }
      
      template<typename ELM>
      static  typename std::enable_if< use_static_downcast<ELM&,TAR>::value,
      TAR     >::type
      access (ELM& elem)
        {
          return static_cast<TAR> (elem);
        }
      
      template<typename ELM>
      static  typename std::enable_if< use_conversion<ELM&,TAR>::value,
      TAR     >::type
      access (ELM& elem)
        {
          return elem;
        }
    };
  
 
} // namespace util
#endif