lib/meta/trait.hpp

/*
  TRAIT.hpp  -  type handling and type detection helpers
 
  Copyright (C)         Lumiera.org
    2009,               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_TRAIT_H
#define LIB_META_TRAIT_H


#include "lib/meta/util.hpp"
#include "lib/meta/duck-detector.hpp"
#include "lib/wrapper.hpp"     

#include <boost/type_traits/is_convertible.hpp>
#include <boost/type_traits/is_arithmetic.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/remove_pointer.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/utility/enable_if.hpp>
#include <string>

//Forward declarations for the Unwrap helper....
namespace boost{
  template<class X> class reference_wrapper; 
}
namespace std {
namespace tr1 {
  template<class X> class reference_wrapper; 
  template<class X> class shared_ptr; 
}}
namespace lumiera{
  template<class X, class B>  class P; 
}
namespace mobject{
  template<class X, class B>  class Placement; 
}


namespace lib {
namespace meta {
  
  
  
  template<typename X>
  struct Unwrap
    {
      typedef X Type;
      
      static  X&
      extract (X const& x)
        {
          return const_cast<X&> (x);
        }
    };
  
  template<typename X>
  struct Unwrap<X*>
    {
      typedef typename boost::remove_cv<X>::type Type;
      
      static Type&
      extract (const X* ptr)
        {
          ASSERT (ptr);
          return const_cast<Type&> (*ptr);
        }
    };
  
  template<typename X>
  struct Unwrap<boost::reference_wrapper<X> >
    {
      typedef X  Type;
      
      static X&
      extract (boost::reference_wrapper<X> wrapped)
        {
          return wrapped;
        }
    };
  
  template<typename X>
  struct Unwrap<std::tr1::reference_wrapper<X> >
    {
      typedef X  Type;
      
      static X&
      extract (std::tr1::reference_wrapper<X> wrapped)
        {
          return wrapped;
        }
    };
  
  template<typename X>
  struct Unwrap<std::tr1::shared_ptr<X> >
    {
      typedef X  Type;
      
      static X&
      extract (std::tr1::shared_ptr<X> ptr)
        {
          ASSERT (ptr);
          return *ptr;
        }
    };
  
  template<typename X, class B>
  struct Unwrap<lumiera::P<X, B> >
    {
      typedef X  Type;
      
      static X&
      extract (lumiera::P<X,B> ptr)
        {
          ASSERT (ptr);
          return *ptr;
        }
    };
  
  template<typename X, class B>
  struct Unwrap<mobject::Placement<X, B> >
    {
      typedef X  Type;
      
      static X&
      extract (mobject::Placement<X,B> placement)
        {
          ASSERT (placement.isValid());
          return *placement;
        }
    };
  
  
  template<typename X>
  typename Unwrap<X>::Type&
  unwrap (X const& wrapped)
  {
    return Unwrap<X>::extract(wrapped);
  }
  
  
  
  
  template<typename X>
  struct Strip
    {
      typedef typename boost::remove_cv<X>                 ::type TypeUnconst;
      typedef typename boost::remove_reference<TypeUnconst>::type TypeReferred;
      typedef typename boost::remove_pointer<TypeReferred> ::type TypePointee;
      typedef typename boost::remove_cv<TypePointee>       ::type TypePlain;
      
      typedef typename Unwrap<TypePlain>                   ::Type Type;
    };
  
  
  
  
  template<typename TY>
  struct RefTraits
    {
      typedef TY* pointer;
      typedef TY& reference;
      typedef TY  value_type;
      typedef value_type member_type;
    };
  
  template<typename TY>
  struct RefTraits<TY *>
    {
      typedef TY* pointer;
      typedef TY& reference;
      typedef TY  value_type;
      typedef pointer member_type;
    };
  
  template<typename TY>
  struct RefTraits<TY &>
    {
      typedef TY* pointer;
      typedef TY& reference;
      typedef TY  value_type;
      typedef lib::wrapper::AssignableRefWrapper<TY> member_type;
    };
  
  
  
  
  
  
  
  
  
  template <typename TY>
  struct can_ToString
    {
      enum { value = boost::is_convertible<TY, std::string>::value
           };
    };
  
  
  template<typename X>
  struct can_lexical2string
    {
      enum { value = boost::is_arithmetic<X>::value
           };
    };
  
  
  
  
  template<typename T>
  class can_STL_ForEach
    {
      typedef typename Strip<T>::Type Type;
       
      struct is_iterable
        {
          META_DETECT_NESTED(iterator);
          META_DETECT_FUNCTION(typename X::iterator, begin,(void));
          META_DETECT_FUNCTION(typename X::iterator, end  ,(void));
          
          enum { value = HasNested_iterator<Type>::value
                      && HasFunSig_begin<Type>::value
                      && HasFunSig_end<Type>::value
           };
        };
      
      struct is_const_iterable
        {
          META_DETECT_NESTED(const_iterator);
          META_DETECT_FUNCTION(typename X::const_iterator, begin,(void) const);
          META_DETECT_FUNCTION(typename X::const_iterator, end  ,(void) const);
          
          enum { value = HasNested_const_iterator<Type>::value
                      && HasFunSig_begin<Type>::value
                      && HasFunSig_end<Type>::value
           };
        };
      
      
    public:
      enum { value = is_iterable::value
                  || is_const_iterable::value
           };
    };
  
  
  template<typename T>
  class can_IterForEach
    {
      typedef typename Strip<T>::Type Type;
       
      META_DETECT_NESTED(value_type);
      META_DETECT_OPERATOR_DEREF();
      META_DETECT_OPERATOR_INC();
      
    public:
      enum{ value = boost::is_convertible<Type, bool>::value
                 && HasNested_value_type<Type>::value
                 && HasOperator_deref<Type>::value
                 && HasOperator_inc<Type>::value
          };
    };
  
  
}} // namespace lib::meta
#endif

---