/usr/include/boost/icl/interval.hpp is in libboost1.46-dev 1.46.1-7ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | /*-----------------------------------------------------------------------------+
Copyright (c) 2010-2010: Joachim Faulhaber
+------------------------------------------------------------------------------+
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENCE.txt or copy at
http://www.boost.org/LICENSE_1_0.txt)
+-----------------------------------------------------------------------------*/
#ifndef BOOST_ICL_INTERVAL_HPP_JOFA_101014
#define BOOST_ICL_INTERVAL_HPP_JOFA_101014
#include <boost/icl/type_traits/interval_type_default.hpp>
namespace boost{ namespace icl
{
template <class IntervalT, bool IsDiscrete, bound_type PretendedBounds, bound_type RepresentedBounds>
struct static_interval;
template <class DomainT, ICL_COMPARE Compare = ICL_COMPARE_INSTANCE(std::less, DomainT)>
struct interval
{
typedef typename interval_type_default<DomainT,Compare>::type interval_type;
typedef interval_type type;
#ifdef BOOST_ICL_USE_STATIC_BOUNDED_INTERVALS
static inline interval_type open(const DomainT& low, const DomainT& up)
{
return
static_interval
< interval_type // if the domain_type is discrete ...
, is_discrete<typename interval_traits<interval_type>::domain_type>::value
, interval_bounds::static_open // 'pretended' bounds will be transformed to
, interval_bound_type<interval_type>::value // the represented bounds
>
::construct(low, up);
}
static inline interval_type left_open(const DomainT& low, const DomainT& up)
{
return
static_interval
< interval_type
, is_discrete<typename interval_traits<interval_type>::domain_type>::value
, interval_bounds::static_left_open
, interval_bound_type<interval_type>::value
>
::construct(low, up);
}
static inline interval_type right_open(const DomainT& low, const DomainT& up)
{
return
static_interval
< interval_type
, is_discrete<typename interval_traits<interval_type>::domain_type>::value
, interval_bounds::static_right_open
, interval_bound_type<interval_type>::value
>
::construct(low, up);
}
static inline interval_type closed(const DomainT& low, const DomainT& up)
{
return
static_interval
< interval_type
, is_discrete<typename interval_traits<interval_type>::domain_type>::value
, interval_bounds::static_closed
, interval_bound_type<interval_type>::value
>
::construct(low, up);
}
static inline interval_type construct(const DomainT& low, const DomainT& up)
{ return icl::construct<interval_type>(low, up); }
#else // ICL_USE_DYNAMIC_INTERVAL_BORDER_DEFAULTS
static inline interval_type right_open(const DomainT& low, const DomainT& up)
{ return icl::construct<interval_type>(low, up, interval_bounds::right_open()); }
static inline interval_type left_open(const DomainT& low, const DomainT& up)
{ return icl::construct<interval_type>(low, up, interval_bounds::left_open()); }
static inline interval_type open(const DomainT& low, const DomainT& up)
{ return icl::construct<interval_type>(low, up, interval_bounds::open()); }
static inline interval_type closed(const DomainT& low, const DomainT& up)
{ return icl::construct<interval_type>(low, up, interval_bounds::closed()); }
static inline interval_type construct(const DomainT& low, const DomainT& up)
{ return icl::construct<interval_type>(low, up); }
#endif
};
template <class IntervalT, bound_type PretendedBounds, bound_type RepresentedBounds>
struct static_interval<IntervalT, true, PretendedBounds, RepresentedBounds>
{// is_discrete<domain_type<IntervalT>>
typedef typename interval_traits<IntervalT>::domain_type domain_type;
static inline IntervalT construct(const domain_type& low, const domain_type& up)
{
return icl::construct<IntervalT>(
shift_lower(interval_bounds(PretendedBounds), interval_bounds(RepresentedBounds), low)
, shift_upper(interval_bounds(PretendedBounds), interval_bounds(RepresentedBounds), up )
);
}
};
template <class IntervalT, bound_type PretendedBounds, bound_type RepresentedBounds>
struct static_interval<IntervalT, false, PretendedBounds, RepresentedBounds>
{// !is_discrete<domain_type<IntervalT>>
typedef typename interval_traits<IntervalT>::domain_type domain_type;
static inline IntervalT construct(const domain_type& low, const domain_type& up)
{
BOOST_STATIC_ASSERT((is_discrete<domain_type>::value || PretendedBounds==RepresentedBounds));
// For domain_types that are not discrete, e.g. interval<float>
// one of the following must hold: If you call
// interval<T>::right_open(x,y) then interval<T>::type must be static_right_open
// interval<T>::left_open(x,y) then interval<T>::type must be static_left_open
// interval<T>::open(x,y) then interval<T>::type must be static_open
// interval<T>::closed(x,y) then interval<T>::type must be static_closed
// Conversion between 'PretendedBounds' and 'RepresentedBounds' is only possible
// for discrete domain_types.
return icl::construct<IntervalT>(low, up);
}
};
}} // namespace boost icl
#endif // BOOST_ICL_INTERVAL_HPP_JOFA_101014
|