ceph/src/boost/boost/icl/type_traits/is_interval.hpp

   1 /*-----------------------------------------------------------------------------+
   2 Copyright (c) 2010-2010: Joachim Faulhaber
   3 +------------------------------------------------------------------------------+
   4    Distributed under the Boost Software License, Version 1.0.
   5       (See accompanying file LICENCE.txt or copy at
   6            http://www.boost.org/LICENSE_1_0.txt)
   7 +-----------------------------------------------------------------------------*/
   8 #ifndef BOOST_ICL_TYPE_TRAITS_IS_INTERVAL_HPP_JOFA_100327
   9 #define BOOST_ICL_TYPE_TRAITS_IS_INTERVAL_HPP_JOFA_100327
  10
  11 #include <boost/mpl/or.hpp>
  12 #include <boost/icl/interval_bounds.hpp>
  13 #include <boost/icl/interval_traits.hpp>
  14
  15 namespace boost{ namespace icl
  16 {
  17
  18 template <class Type>
  19 struct interval_bound_type
  20 {
  21     typedef interval_bound_type type;
  22     BOOST_STATIC_CONSTANT(bound_type, value = (interval_bounds::undefined));
  23 };
  24
  25 template <class Type> struct is_interval
  26 {
  27     typedef is_interval<Type> type;
  28     BOOST_STATIC_CONSTANT(bool,
  29         value = ((interval_bound_type<Type>::value) < interval_bounds::undefined));
  30 };
  31
  32
  33 template <class Type> struct has_static_bounds
  34 {
  35     typedef has_static_bounds<Type> type;
  36     BOOST_STATIC_CONSTANT(bool,
  37         value = ((interval_bound_type<Type>::value) < interval_bounds::dynamic));
  38 };
  39
  40 template <class Type> struct has_dynamic_bounds
  41 {
  42     typedef has_dynamic_bounds<Type> type;
  43     BOOST_STATIC_CONSTANT(bool,
  44         value = (interval_bound_type<Type>::value == interval_bounds::dynamic));
  45 };
  46
  47 template <class Type> struct has_asymmetric_bounds
  48 {
  49     typedef has_asymmetric_bounds<Type> type;
  50     BOOST_STATIC_CONSTANT(bound_type, bounds = (interval_bound_type<Type>::value));
  51     BOOST_STATIC_CONSTANT(bool,
  52         value = (   bounds == interval_bounds::static_left_open
  53                  || bounds == interval_bounds::static_right_open));
  54 };
  55
  56 template <class Type> struct has_symmetric_bounds
  57 {
  58     typedef has_symmetric_bounds<Type> type;
  59     BOOST_STATIC_CONSTANT(bound_type, bounds = (interval_bound_type<Type>::value));
  60     BOOST_STATIC_CONSTANT(bool,
  61         value = (   bounds == interval_bounds::static_closed
  62                  || bounds == interval_bounds::static_open));
  63 };
  64
  65 //------------------------------------------------------------------------------
  66 template <class Type> struct is_discrete_static
  67 {
  68     typedef is_discrete_static type;
  69     typedef typename interval_traits<Type>::domain_type domain_type;
  70     BOOST_STATIC_CONSTANT(bool,
  71         value = (mpl::and_< has_static_bounds<Type>
  72                           , is_discrete<domain_type> >::value) );
  73 };
  74
  75 //------------------------------------------------------------------------------
  76 template <class Type> struct is_continuous_static
  77 {
  78     typedef is_continuous_static type;
  79     typedef typename interval_traits<Type>::domain_type domain_type;
  80     BOOST_STATIC_CONSTANT(bool,
  81         value = (mpl::and_< has_static_bounds<Type>
  82                           , is_continuous<domain_type>
  83                           , has_asymmetric_bounds<Type> >::value) );
  84 };
  85
  86 //------------------------------------------------------------------------------
  87 template <class Type> struct is_static_right_open
  88 {
  89     typedef is_static_right_open<Type> type;
  90     BOOST_STATIC_CONSTANT(bool,
  91         value = (interval_bound_type<Type>::value == interval_bounds::static_right_open));
  92 };
  93
  94 template <class Type> struct is_static_left_open
  95 {
  96     typedef is_static_left_open<Type> type;
  97     BOOST_STATIC_CONSTANT(bool,
  98         value = (interval_bound_type<Type>::value == interval_bounds::static_left_open));
  99 };
 100
 101 template <class Type> struct is_static_open
 102 {
 103     typedef is_static_open<Type> type;
 104     BOOST_STATIC_CONSTANT(bool,
 105         value = (interval_bound_type<Type>::value == interval_bounds::static_open));
 106 };
 107
 108 template <class Type> struct is_static_closed
 109 {
 110     typedef is_static_closed<Type> type;
 111     BOOST_STATIC_CONSTANT(bool,
 112         value = (interval_bound_type<Type>::value == interval_bounds::static_closed));
 113 };
 114
 115 template <class Type> struct is_discrete_static_closed
 116 {
 117     typedef is_static_closed<Type> type;
 118     typedef typename interval_traits<Type>::domain_type domain_type;
 119
 120     BOOST_STATIC_CONSTANT( bool,
 121         value = (mpl::and_< is_static_closed<Type>
 122                           , is_discrete<domain_type> >::value) );
 123 };
 124
 125 template <class Type> struct is_discrete_static_open
 126 {
 127     typedef is_static_closed<Type> type;
 128     typedef typename interval_traits<Type>::domain_type domain_type;
 129
 130     BOOST_STATIC_CONSTANT( bool,
 131         value = (mpl::and_< is_static_open<Type>
 132                           , is_discrete<domain_type> >::value) );
 133 };
 134
 135 //------------------------------------------------------------------------------
 136 template <class Type> struct is_continuous_right_open
 137 {
 138     typedef is_continuous_right_open<Type> type;
 139     typedef typename interval_traits<Type>::domain_type domain_type;
 140     BOOST_STATIC_CONSTANT(bool,
 141         value = (mpl::and_<is_static_right_open<Type>, is_continuous<domain_type> >::value));
 142 };
 143
 144 template <class Type> struct is_continuous_left_open
 145 {
 146     typedef is_continuous_left_open<Type> type;
 147     typedef typename interval_traits<Type>::domain_type domain_type;
 148     BOOST_STATIC_CONSTANT(bool,
 149         value = (mpl::and_<is_static_left_open<Type>, is_continuous<domain_type> >::value));
 150 };
 151
 152 //------------------------------------------------------------------------------
 153
 154 template <class Type> struct is_singelizable
 155 {
 156     typedef is_singelizable type;
 157     typedef typename interval_traits<Type>::domain_type domain_type;
 158
 159     BOOST_STATIC_CONSTANT(bool,
 160         value =
 161             (mpl::or_< has_dynamic_bounds<Type>
 162                      , is_discrete<domain_type>
 163                      >::value)
 164     );
 165 };
 166
 167 }} // namespace boost icl
 168
 169 #endif
 170
 171