epoc32/include/stdapis/boost/pending/ct_if.hpp
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:33:34 +0100
branchSymbian3
changeset 4 837f303aceeb
permissions -rw-r--r--
Current Symbian^3 public API header files (from PDK 3.0.h)
This is the epoc32/include tree with the "platform" subtrees removed, and
all but a selected few mbg and rsg files removed.
     1 // (C) Copyright Jeremy Siek 2000.
     2 // Distributed under the Boost Software License, Version 1.0. (See
     3 // accompanying file LICENSE_1_0.txt or copy at
     4 // http://www.boost.org/LICENSE_1_0.txt)
     5 
     6 // The ct_if implementation that avoids partial specialization is
     7 // based on the IF class by Ulrich W. Eisenecker and Krzysztof
     8 // Czarnecki.
     9 
    10 #ifndef BOOST_CT_IF_HPP
    11 #define BOOST_CT_IF_HPP
    12 
    13 #include <boost/config.hpp>
    14 
    15 /*
    16   There is a bug in the Borland compiler with regards to using
    17   integers to specialize templates. This made it hard to use ct_if in
    18   the graph library. Changing from 'ct_if' to 'ct_if_t' fixed the
    19   problem.
    20 */
    21 
    22 #include <boost/type_traits/integral_constant.hpp> // true_type and false_type
    23 
    24 namespace boost {
    25 
    26   struct ct_if_error { };
    27 
    28   template <class A, class B>
    29   struct ct_and { typedef false_type type; };
    30   template <> struct ct_and<true_type,true_type> { typedef true_type type; };
    31 
    32   template <class A> struct ct_not { typedef ct_if_error type; };
    33   template <> struct ct_not<true_type> { typedef false_type type; };
    34   template <> struct ct_not<false_type> { typedef true_type type; };
    35 
    36 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    37 
    38 // agurt, 15/sep/02: in certain cases Borland has problems with
    39 // choosing the right 'ct_if' specialization even though 'cond' 
    40 // _does_ equal '1'; the easiest way to fix it is to make first 
    41 // 'ct_if' non-type template parameter boolean.
    42 #if !defined(__BORLANDC__)
    43   template <bool cond, class A, class B>
    44   struct ct_if { typedef ct_if_error type; };
    45   template <class A, class B>
    46   struct ct_if<true, A, B> { typedef A type; };
    47   template <class A, class B>
    48   struct ct_if<false, A, B> { typedef B type; };
    49 #else
    50   template <bool cond, class A, class B>
    51   struct ct_if { typedef A type; };
    52   template <class A, class B>
    53   struct ct_if<false, A, B> { typedef B type; };
    54 #endif
    55 
    56   template <class cond, class A, class B>
    57   struct ct_if_t { typedef ct_if_error type; };
    58   template <class A, class B>
    59   struct ct_if_t<true_type, A, B> { typedef A type; };
    60   template <class A, class B>
    61   struct ct_if_t<false_type, A, B> { typedef B type; };
    62 
    63 #else
    64 
    65   namespace detail {
    66 
    67     template <int condition, class A, class B> struct IF;
    68     template <int condition> struct SlectSelector;
    69     struct SelectFirstType;
    70     struct SelectSecondType;
    71     
    72     struct SelectFirstType {
    73       template<class A, class B>
    74       struct Template {        typedef A type; };
    75     };
    76     
    77     struct SelectSecondType {
    78       template<class A, class B>
    79       struct Template { typedef B type; };
    80     };
    81     
    82     template<int condition>
    83     struct SlectSelector {
    84       typedef SelectFirstType type;
    85     };
    86     
    87     template <>
    88     struct SlectSelector<0> {
    89       typedef SelectSecondType type;
    90     };
    91 
    92   } // namespace detail
    93     
    94   template<int condition, class A, class B>
    95   struct ct_if
    96   {
    97     typedef typename detail::SlectSelector<condition>::type Selector;
    98     typedef typename Selector::template Template<A, B>::type type;
    99   };
   100   
   101   template <class cond, class A, class B>
   102   struct ct_if_t { 
   103     typedef typename ct_if<cond::value, A, B>::type type;
   104   };
   105 
   106 #endif
   107 
   108 } // namespace boost
   109 
   110 #endif // BOOST_CT_IF_HPP
   111