/usr/include/boost/units/operators.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 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | // Boost.Units - A C++ library for zero-overhead dimensional analysis and
// unit/quantity manipulation and conversion
//
// Copyright (C) 2003-2008 Matthias Christian Schabel
// Copyright (C) 2008 Steven Watanabe
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_UNITS_OPERATORS_HPP
#define BOOST_UNITS_OPERATORS_HPP
///
/// \file
/// \brief Compile time operators and typeof helper classes.
/// \details
/// These operators declare the compile-time operators needed to support dimensional
/// analysis algebra. They require the use of Boost.Typeof, emulation or native.
/// Typeof helper classes define result type for heterogeneous operators on value types.
/// These must be defined through specialization for powers and roots.
///
#include <boost/static_assert.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/units/config.hpp>
namespace boost {
namespace units {
#if BOOST_UNITS_HAS_TYPEOF
#ifndef BOOST_UNITS_DOXYGEN
// to avoid need for default constructor and eliminate divide by zero errors.
namespace typeof_ {
/// INTERNAL ONLY
template<class T> T make();
} // namespace typeof_
#endif
#if (BOOST_UNITS_HAS_BOOST_TYPEOF)
template<typename X> struct unary_plus_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (+typeof_::make<X>()))
typedef typename nested::type type;
};
template<typename X> struct unary_minus_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (-typeof_::make<X>()))
typedef typename nested::type type;
};
template<typename X,typename Y> struct add_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (typeof_::make<X>()+typeof_::make<Y>()))
typedef typename nested::type type;
};
template<typename X,typename Y> struct subtract_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (typeof_::make<X>()-typeof_::make<Y>()))
typedef typename nested::type type;
};
template<typename X,typename Y> struct multiply_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (typeof_::make<X>()*typeof_::make<Y>()))
typedef typename nested::type type;
};
template<typename X,typename Y> struct divide_typeof_helper
{
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(nested, (typeof_::make<X>()/typeof_::make<Y>()))
typedef typename nested::type type;
};
#elif (BOOST_UNITS_HAS_MWERKS_TYPEOF)
template<typename X> struct unary_plus_typeof_helper { typedef __typeof__((+typeof_::make<X>())) type; };
template<typename X> struct unary_minus_typeof_helper { typedef __typeof__((-typeof_::make<X>())) type; };
template<typename X,typename Y> struct add_typeof_helper { typedef __typeof__((typeof_::make<X>()+typeof_::make<Y>())) type; };
template<typename X,typename Y> struct subtract_typeof_helper { typedef __typeof__((typeof_::make<X>()-typeof_::make<Y>())) type; };
template<typename X,typename Y> struct multiply_typeof_helper { typedef __typeof__((typeof_::make<X>()*typeof_::make<Y>())) type; };
template<typename X,typename Y> struct divide_typeof_helper { typedef __typeof__((typeof_::make<X>()/typeof_::make<Y>())) type; };
#elif (BOOST_UNITS_HAS_GNU_TYPEOF) || defined(BOOST_UNITS_DOXYGEN)
template<typename X> struct unary_plus_typeof_helper { typedef typeof((+typeof_::make<X>())) type; };
template<typename X> struct unary_minus_typeof_helper { typedef typeof((-typeof_::make<X>())) type; };
template<typename X,typename Y> struct add_typeof_helper { typedef typeof((typeof_::make<X>()+typeof_::make<Y>())) type; };
template<typename X,typename Y> struct subtract_typeof_helper { typedef typeof((typeof_::make<X>()-typeof_::make<Y>())) type; };
template<typename X,typename Y> struct multiply_typeof_helper { typedef typeof((typeof_::make<X>()*typeof_::make<Y>())) type; };
template<typename X,typename Y> struct divide_typeof_helper { typedef typeof((typeof_::make<X>()/typeof_::make<Y>())) type; };
#endif
#else // BOOST_UNITS_HAS_TYPEOF
template<typename X> struct unary_plus_typeof_helper { typedef X type; };
template<typename X> struct unary_minus_typeof_helper { typedef X type; };
template<typename X,typename Y> struct add_typeof_helper { BOOST_STATIC_ASSERT((is_same<X,Y>::value == true)); typedef X type; };
template<typename X,typename Y> struct subtract_typeof_helper { BOOST_STATIC_ASSERT((is_same<X,Y>::value == true)); typedef X type; };
template<typename X,typename Y> struct multiply_typeof_helper { BOOST_STATIC_ASSERT((is_same<X,Y>::value == true)); typedef X type; };
template<typename X,typename Y> struct divide_typeof_helper { BOOST_STATIC_ASSERT((is_same<X,Y>::value == true)); typedef X type; };
#endif // BOOST_UNITS_HAS_TYPEOF
template<typename X,typename Y> struct power_typeof_helper;
template<typename X,typename Y> struct root_typeof_helper;
#ifdef BOOST_UNITS_DOXYGEN
/// A helper used by @c pow to raise
/// a runtime object to a compile time
/// known exponent. This template is intended to
/// be specialized. All specializations must
/// conform to the interface shown here.
/// @c Exponent will be either the exponent
/// passed to @c pow or @c static_rational<N>
/// for and integer argument, N.
template<typename BaseType, typename Exponent>
struct power_typeof_helper
{
/// specifies the result type
typedef detail::unspecified type;
/// Carries out the runtime calculation.
static type value(const BaseType& base);
};
/// A helper used by @c root to take a root
/// of a runtime object using a compile time
/// known index. This template is intended to
/// be specialized. All specializations must
/// conform to the interface shown here.
/// @c Index will be either the type
/// passed to @c pow or @c static_rational<N>
/// for and integer argument, N.
template<typename Radicand, typename Index>
struct root_typeof_helper
{
/// specifies the result type
typedef detail::unspecified type;
/// Carries out the runtime calculation.
static type value(const Radicand& base);
};
#endif
} // namespace units
} // namespace boost
#endif // BOOST_UNITS_OPERATORS_HPP
|