← Back to branch summary

~ubuntu-branches/ubuntu/wily/bombono-dvd/wily

« back to all changes in this revision

Viewing changes to libs/boost-lib/boost/pending/ct_if.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-11-04 11:46:25 UTC
  • mto: This revision was merged to the branch mainline in revision 8.
  • Revision ID: james.westby@ubuntu.com-20101104114625-8xfdhvhpsm51i0nu
Tags: upstream-0.8.0
Import upstream version 0.8.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
libs/boost-lib/boost/pending/ct_if.hpp
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