verdnatura-mirror
/
verdnatura-chat
forked from verdnatura-mirror/Rocket.Chat.ReactNative
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
verdnatura-chat/ios/Pods/boost-for-react-native/boost/units/lambda.hpp

594 lines
27 KiB
C++
Raw Normal View History

Update RN to 0.59.8 (#896) * update IOS react native to 0.59.8 * update Android react native to 0.59.8 * fix eslint errors * Android debug working * Android build * Fix lint * Making jest happy * Update CircleCI android image * Fix android build * Use 32 bits * Fix iOS build * Update detox * Use new Xcode build system * Use old build system * Update realm (64 bits support)
2019-05-22 20:15:35 +00:00
// 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)
// $Id: lambda.hpp 27 2008-06-16 14:50:58Z maehne $
#ifndef BOOST_UNITS_LAMBDA_HPP
#define BOOST_UNITS_LAMBDA_HPP
////////////////////////////////////////////////////////////////////////
///
/// \file lambda.hpp
///
/// \brief Definitions to ease the usage of Boost.Units' quantity,
/// unit, and absolute types in functors created with the
/// Boost.Lambda library.
///
/// \author Torsten Maehne
/// \date 2008-06-16
///
/// Boost.Lambda's return type deduction system is extented to make
/// use of Boost.Units' typeof_helper trait classes for Boost.Units'
/// quantity, absolute, and unit template classes.
///
////////////////////////////////////////////////////////////////////////
#include <boost/lambda/lambda.hpp>
#include <boost/units/units_fwd.hpp>
#include <boost/units/detail/dimensionless_unit.hpp>
#include <boost/units/operators.hpp>
namespace boost {
namespace lambda {
/// Partial specialization of return type trait for action
/// unit<Dim, System> * Y.
template<typename System, typename Dim, typename Y>
struct plain_return_type_2<arithmetic_action<multiply_action>,
boost::units::unit<Dim, System>,
Y > {
typedef typename boost::units::multiply_typeof_helper<
boost::units::unit<Dim, System>, Y >::type type;
};
} // namespace lambda
namespace units {
template<typename System, typename Dim, typename Arg>
struct multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > {
typedef boost::lambda::lambda_functor<
boost::lambda::lambda_functor_base<
boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> >
>
> type;
};
/// Disambiguating overload for action
/// unit<Dim, System> * lambda_functor<Arg>
/// based on \<boost/lambda/detail/operators.hpp\>.
template<typename System, typename Dim, typename Arg>
inline const typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type
operator*(const boost::units::unit<Dim, System>& a,
const boost::lambda::lambda_functor<Arg>& b) {
return typename multiply_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited
(tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type,
boost::lambda::lambda_functor<Arg> >
(a, b));
}
} // namespace units
namespace lambda {
/// Partial specialization of return type trait for action
/// unit<Dim, System> / Y.
template<typename System, typename Dim, typename Y>
struct plain_return_type_2<arithmetic_action<divide_action>,
boost::units::unit<Dim, System>,
Y > {
typedef typename boost::units::divide_typeof_helper<
boost::units::unit<Dim, System>, Y >::type type;
};
} // namespace lambda
namespace units {
template<typename System, typename Dim, typename Arg>
struct divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> > {
typedef boost::lambda::lambda_functor<
boost::lambda::lambda_functor_base<
boost::lambda::arithmetic_action<boost::lambda::divide_action>,
tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type, boost::lambda::lambda_functor<Arg> >
>
> type;
};
/// Disambiguating overload for action
/// unit<Dim, System> / lambda_functor<Arg>
/// based on \<boost/lambda/detail/operators.hpp\>.
template<typename System, typename Dim, typename Arg>
inline const typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type
operator/(const boost::units::unit<Dim, System>& a,
const boost::lambda::lambda_functor<Arg>& b) {
return typename divide_typeof_helper<boost::units::unit<Dim, System>, boost::lambda::lambda_functor<Arg> >::type::inherited
(tuple<typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type,
boost::lambda::lambda_functor<Arg> >
(a, b));
}
} // namespace units
namespace lambda {
/// Partial specialization of return type trait for action
/// Y * unit<Dim, System>.
template<typename System, typename Dim, typename Y>
struct plain_return_type_2<arithmetic_action<multiply_action>,
Y,
boost::units::unit<Dim, System> > {
typedef typename boost::units::multiply_typeof_helper<
Y, boost::units::unit<Dim, System> >::type type;
};
} // namespace lambda
namespace units {
template<typename System, typename Dim, typename Arg>
struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > {
typedef boost::lambda::lambda_functor<
boost::lambda::lambda_functor_base<
boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
>
> type;
};
/// Disambiguating overload for action
/// lambda_functor<Arg> * unit<Dim, System>
/// based on \<boost/lambda/detail/operators.hpp\>.
template<typename System, typename Dim, typename Arg>
inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type
operator*(const boost::lambda::lambda_functor<Arg>& a,
const boost::units::unit<Dim, System>& b) {
return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited
(tuple<boost::lambda::lambda_functor<Arg>,
typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
(a, b));
}
} // namespace units
namespace lambda {
/// Partial specialization of return type trait for action
/// Y / unit<Dim, System>.
template<typename System, typename Dim, typename Y>
struct plain_return_type_2<arithmetic_action<divide_action>,
Y,
boost::units::unit<Dim, System> > {
typedef typename boost::units::divide_typeof_helper<
Y, boost::units::unit<Dim, System> >::type type;
};
} // namespace lambda
namespace units {
template<typename System, typename Dim, typename Arg>
struct divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> > {
typedef boost::lambda::lambda_functor<
boost::lambda::lambda_functor_base<
boost::lambda::arithmetic_action<boost::lambda::divide_action>,
tuple<boost::lambda::lambda_functor<Arg>, typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
>
> type;
};
/// Disambiguating overload for action
/// lambda_functor<Arg> / unit<Dim, System>
/// based on \<boost/lambda/detail/operators.hpp\>.
template<typename System, typename Dim, typename Arg>
inline const typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type
operator/(const boost::lambda::lambda_functor<Arg>& a,
const boost::units::unit<Dim, System>& b) {
return typename divide_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::unit<Dim, System> >::type::inherited
(tuple<boost::lambda::lambda_functor<Arg>,
typename boost::lambda::const_copy_argument<const boost::units::unit<Dim, System> >::type>
(a, b));
}
} // namespace units
namespace lambda {
/// Partial specialization of return type trait for action
/// quantity<Unit, X> * X.
template<typename Unit, typename X>
struct plain_return_type_2<arithmetic_action<multiply_action>,
boost::units::quantity<Unit, X>,
X> {
typedef typename boost::units::multiply_typeof_helper<
boost::units::quantity<Unit, X>, X>::type type;
};
/// Partial specialization of return type trait for action
/// X * quantity<Unit, X>.
template<typename Unit, typename X>
struct plain_return_type_2<arithmetic_action<multiply_action>,
X,
boost::units::quantity<Unit, X> > {
typedef typename boost::units::multiply_typeof_helper<
X, boost::units::quantity<Unit, X> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<Unit, X> / X.
template<typename Unit, typename X>
struct plain_return_type_2<arithmetic_action<divide_action>,
boost::units::quantity<Unit, X>,
X> {
typedef typename boost::units::divide_typeof_helper<
boost::units::quantity<Unit, X>, X>::type type;
};
/// Partial specialization of return type trait for action
/// X / quantity<Unit, X>.
template<typename Unit, typename X>
struct plain_return_type_2<arithmetic_action<divide_action>,
X,
boost::units::quantity<Unit, X> > {
typedef typename boost::units::divide_typeof_helper<
X, boost::units::quantity<Unit, X> >::type type;
};
/// Partial specialization of return type trait for action
/// unit<Dim1, System1> * quantity<Unit2, Y>.
template<typename System1, typename Dim1, typename Unit2, typename Y>
struct plain_return_type_2<arithmetic_action<multiply_action>,
boost::units::unit<Dim1, System1>,
boost::units::quantity<Unit2, Y> > {
typedef typename boost::units::multiply_typeof_helper<
boost::units::unit<Dim1, System1>,
boost::units::quantity<Unit2, Y> >::type type;
};
/// Partial specialization of return type trait for action
/// unit<Dim1, System1> / quantity<Unit2, Y>.
template<typename System1, typename Dim1, typename Unit2, typename Y>
struct plain_return_type_2<arithmetic_action<divide_action>,
boost::units::unit<Dim1, System1>,
boost::units::quantity<Unit2, Y> > {
typedef typename boost::units::divide_typeof_helper<
boost::units::unit<Dim1, System1>,
boost::units::quantity<Unit2, Y> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<Unit1, Y> * unit<Dim2, System2>.
template<typename Unit1, typename Y, typename System2, typename Dim2>
struct plain_return_type_2<arithmetic_action<multiply_action>,
boost::units::quantity<Unit1, Y>,
boost::units::unit<Dim2, System2> > {
typedef typename boost::units::multiply_typeof_helper<
boost::units::quantity<Unit1, Y>,
boost::units::unit<Dim2, System2> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<Unit1, Y> / unit<Dim2, System2>.
template<typename Unit1, typename Y, typename System2, typename Dim2>
struct plain_return_type_2<arithmetic_action<divide_action>,
boost::units::quantity<Unit1, Y>,
boost::units::unit<Dim2, System2> > {
typedef typename boost::units::divide_typeof_helper<
boost::units::quantity<Unit1, Y>,
boost::units::unit<Dim2, System2> >::type type;
};
/// Partial specialization of return type trait for action
/// +quantity<Unit, Y>.
template<typename Unit, typename Y>
struct plain_return_type_1<unary_arithmetic_action<plus_action>,
boost::units::quantity<Unit, Y> > {
typedef typename boost::units::unary_plus_typeof_helper<
boost::units::quantity<Unit, Y> >::type type;
};
/// Partial specialization of return type trait for action
/// -quantity<Unit, Y>.
template<typename Unit, typename Y>
struct plain_return_type_1<unary_arithmetic_action<minus_action>,
boost::units::quantity<Unit, Y> > {
typedef typename boost::units::unary_minus_typeof_helper<
boost::units::quantity<Unit, Y> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<Unit1, X> + quantity<Unit2, Y>.
template<typename Unit1, typename X, typename Unit2, typename Y>
struct plain_return_type_2<arithmetic_action<plus_action>,
boost::units::quantity<Unit1, X>,
boost::units::quantity<Unit2, Y> > {
typedef typename boost::units::add_typeof_helper<
boost::units::quantity<Unit1, X>,
boost::units::quantity<Unit2, Y> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<dimensionless, X> + Y.
template<typename System, typename X, typename Y>
struct plain_return_type_2<arithmetic_action<plus_action>,
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
Y> {
typedef typename boost::units::add_typeof_helper<
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
Y>::type type;
};
/// Partial specialization of return type trait for action
/// X + quantity<dimensionless, Y>.
template<typename System, typename X, typename Y>
struct plain_return_type_2<arithmetic_action<plus_action>,
X,
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
typedef typename boost::units::add_typeof_helper<
X,
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<Unit1, X> - quantity<Unit2, Y>.
template<typename Unit1, typename X, typename Unit2, typename Y>
struct plain_return_type_2<arithmetic_action<minus_action>,
boost::units::quantity<Unit1, X>,
boost::units::quantity<Unit2, Y> > {
typedef typename boost::units::subtract_typeof_helper<
boost::units::quantity<Unit1, X>,
boost::units::quantity<Unit2, Y> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<dimensionless, X> - Y.
template<typename System, typename X, typename Y>
struct plain_return_type_2<arithmetic_action<minus_action>,
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
Y> {
typedef typename boost::units::subtract_typeof_helper<
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), X>,
Y>::type type;
};
/// Partial specialization of return type trait for action
/// X - quantity<dimensionless, Y>.
template<typename System, typename X, typename Y>
struct plain_return_type_2<arithmetic_action<minus_action>,
X,
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> > {
typedef typename boost::units::subtract_typeof_helper<
X,
boost::units::quantity<BOOST_UNITS_DIMENSIONLESS_UNIT(System), Y> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<Unit1, X> * quantity<Unit2, Y>.
template<typename Unit1, typename X, typename Unit2, typename Y>
struct plain_return_type_2<arithmetic_action<multiply_action>,
boost::units::quantity<Unit1, X>,
boost::units::quantity<Unit2, Y> > {
typedef typename boost::units::multiply_typeof_helper<
boost::units::quantity<Unit1, X>,
boost::units::quantity<Unit2, Y> >::type type;
};
/// Partial specialization of return type trait for action
/// quantity<Unit1, X> / quantity<Unit2, Y>.
template<typename Unit1, typename X, typename Unit2, typename Y>
struct plain_return_type_2<arithmetic_action<divide_action>,
boost::units::quantity<Unit1, X>,
boost::units::quantity<Unit2, Y> > {
typedef typename boost::units::divide_typeof_helper<
boost::units::quantity<Unit1, X>,
boost::units::quantity<Unit2, Y> >::type type;
};
////////////////////////////////////////////////////////////////////////
// Partial specialization of Boost.Lambda's trait classes for all
// operators overloaded in <boost/units/unit.hpp>
////////////////////////////////////////////////////////////////////////
/// Partial specialization of return type trait for action
/// +unit<Dim, System>.
template<typename Dim, typename System>
struct plain_return_type_1<unary_arithmetic_action<plus_action>,
boost::units::unit<Dim, System> > {
typedef typename boost::units::unary_plus_typeof_helper<
boost::units::unit<Dim, System> >::type type;
};
/// Partial specialization of return type trait for action
/// -unit<Dim, System>.
template<typename Dim, typename System>
struct plain_return_type_1<unary_arithmetic_action<minus_action>,
boost::units::unit<Dim, System> > {
typedef typename boost::units::unary_minus_typeof_helper<
boost::units::unit<Dim, System> >::type type;
};
/// Partial specialization of return type trait for action
/// unit<Dim1, System1> + unit<Dim2, System2>.
template<typename Dim1, typename Dim2, typename System1, typename System2>
struct plain_return_type_2<arithmetic_action<plus_action>,
boost::units::unit<Dim1, System1>,
boost::units::unit<Dim2, System2> > {
typedef typename boost::units::add_typeof_helper<
boost::units::unit<Dim1, System1>,
boost::units::unit<Dim2, System2> >::type type;
};
/// Partial specialization of return type trait for action
/// unit<Dim1, System1> - unit<Dim2, System2>.
template<typename Dim1, typename Dim2, typename System1, typename System2>
struct plain_return_type_2<arithmetic_action<minus_action>,
boost::units::unit<Dim1, System1>,
boost::units::unit<Dim2, System2> > {
typedef typename boost::units::subtract_typeof_helper<
boost::units::unit<Dim1, System1>,
boost::units::unit<Dim2, System2> >::type type;
};
/// Partial specialization of return type trait for action
/// unit<Dim1, System1> * unit<Dim2, System2>.
template<typename Dim1, typename Dim2, typename System1, typename System2>
struct plain_return_type_2<arithmetic_action<multiply_action>,
boost::units::unit<Dim1, System1>,
boost::units::unit<Dim2, System2> > {
typedef typename boost::units::multiply_typeof_helper<
boost::units::unit<Dim1, System1>,
boost::units::unit<Dim2, System2> >::type type;
};
/// Partial specialization of return type trait for action
/// unit<Dim1, System1> / unit<Dim2, System2>.
template<typename Dim1, typename Dim2, typename System1, typename System2>
struct plain_return_type_2<arithmetic_action<divide_action>,
boost::units::unit<Dim1, System1>,
boost::units::unit<Dim2, System2> > {
typedef typename boost::units::divide_typeof_helper<
boost::units::unit<Dim1, System1>,
boost::units::unit<Dim2, System2> >::type type;
};
////////////////////////////////////////////////////////////////////////
// Partial specialization of Boost.Lambda's trait classes for all
// operators overloaded in <boost/units/absolute.hpp>
////////////////////////////////////////////////////////////////////////
/// Partial specialization of return type trait for action
/// absolute<Y> + Y.
template<typename Y>
struct plain_return_type_2<arithmetic_action<plus_action>,
boost::units::absolute<Y>,
Y> {
typedef typename boost::units::absolute<Y> type;
};
/// Partial specialization of return type trait for action
/// Y + absolute<Y>.
template<typename Y>
struct plain_return_type_2<arithmetic_action<plus_action>,
Y,
boost::units::absolute<Y> > {
typedef typename boost::units::absolute<Y> type;
};
/// Partial specialization of return type trait for action
/// absolute<Y> - Y.
template<typename Y>
struct plain_return_type_2<arithmetic_action<minus_action>,
boost::units::absolute<Y>,
Y> {
typedef typename boost::units::absolute<Y> type;
};
/// Partial specialization of return type trait for action
/// absolute<Y> - absolute<Y>.
template<typename Y>
struct plain_return_type_2<arithmetic_action<minus_action>,
boost::units::absolute<Y>,
boost::units::absolute<Y> > {
typedef Y type;
};
/// Partial specialization of return type trait for action
/// T * absolute<unit<D, S> >.
template<typename D, typename S, typename T>
struct plain_return_type_2<arithmetic_action<multiply_action>,
T,
boost::units::absolute<boost::units::unit<D, S> > > {
typedef typename boost::units::quantity<
boost::units::absolute<boost::units::unit<D, S> >, T> type;
};
} // namespace lambda
namespace units {
template<typename System, typename Dim, typename Arg>
struct multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > > {
typedef boost::lambda::lambda_functor<
boost::lambda::lambda_functor_base<
boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
tuple<boost::lambda::lambda_functor<Arg>,
typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type>
>
> type;
};
/// Disambiguating overload for action
/// lambda_functor<Arg> * absolute<unit<Dim, System> >
/// based on \<boost/lambda/detail/operators.hpp\>.
template<typename System, typename Dim, typename Arg>
inline const typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type
operator*(const boost::lambda::lambda_functor<Arg>& a,
const boost::units::absolute<boost::units::unit<Dim, System> >& b) {
return typename multiply_typeof_helper<boost::lambda::lambda_functor<Arg>, boost::units::absolute<boost::units::unit<Dim, System> > >::type::inherited
(tuple<boost::lambda::lambda_functor<Arg>,
typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type>
(a, b));
}
} // namespace units
namespace lambda {
/// Partial specialization of return type trait for action
/// absolute<unit<D, S> > * T.
template<typename D, typename S, typename T>
struct plain_return_type_2<arithmetic_action<multiply_action>,
boost::units::absolute<boost::units::unit<D, S> >,
T> {
typedef typename boost::units::quantity<
boost::units::absolute<boost::units::unit<D, S> >, T> type;
};
} // namespace lambda
namespace units {
template<typename System, typename Dim, typename Arg>
struct multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> > {
typedef boost::lambda::lambda_functor<
boost::lambda::lambda_functor_base<
boost::lambda::arithmetic_action<boost::lambda::multiply_action>,
tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type,
boost::lambda::lambda_functor<Arg> >
>
> type;
};
/// Disambiguating overload for action
/// absolute<unit<Dim, System> > * lambda_functor<Arg>
/// based on \<boost/lambda/detail/operators.hpp\>.
template<typename System, typename Dim, typename Arg>
inline const typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type
operator*(const boost::units::absolute<boost::units::unit<Dim, System> >& a,
const boost::lambda::lambda_functor<Arg>& b) {
return typename multiply_typeof_helper<boost::units::absolute<boost::units::unit<Dim, System> >, boost::lambda::lambda_functor<Arg> >::type::inherited
(tuple<typename boost::lambda::const_copy_argument<const boost::units::absolute<boost::units::unit<Dim, System> > >::type,
boost::lambda::lambda_functor<Arg> >
(a, b));
}
} // namespace units
} // namespace boost
#endif // BOOST_UNITS_LAMBDA_HPP