BVB Source Codes

mars Show functional_fwd.hpp Source code

Return Download mars: download functional_fwd.hpp Source code - Download mars Source code - Type:.hpp
  1. ///////////////////////////////////////////////////////////////////////////////
  2. /// \file functional_fwd.hpp
  3. ///
  4. //  Copyright 2005 Eric Niebler. Distributed under the Boost
  5. //  Software License, Version 1.0. (See accompanying file
  6. //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  7.  
  8. #ifndef BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005
  9. #define BOOST_NUMERIC_FUNCTIONAL_FWD_HPP_EAN_08_12_2005
  10.  
  11. #include <boost/mpl/if.hpp>
  12. #include <boost/mpl/placeholders.hpp>
  13. #include <boost/utility/enable_if.hpp>
  14. #include <boost/type_traits/is_same.hpp>
  15. #include <boost/type_traits/is_const.hpp>
  16.  
  17. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost { namespace numeric
  18. {
  19.     // For using directives -- this namespace may be re-opened elsewhere
  20.     namespace operators
  21.     {}
  22.  
  23.     namespace op
  24.     {
  25.         using mpl::_;
  26.         using mpl::_1;
  27.         using mpl::_2;
  28.     }
  29.  
  30.     namespace functional
  31.     {
  32.         using namespace operators;
  33.  
  34.         template<typename T>
  35.         struct tag
  36.         {
  37.             typedef void type;
  38.         };
  39.  
  40.         template<typename T>
  41.         struct tag<T const>
  42.           : tag<T>
  43.         {};
  44.  
  45.         template<typename T>
  46.         struct tag<T volatile>
  47.           : tag<T>
  48.         {};
  49.  
  50.         template<typename T>
  51.         struct tag<T const volatile>
  52.           : tag<T>
  53.         {};
  54.  
  55.         template<typename T>
  56.         struct static_;
  57.  
  58.         template<typename A0, typename A1>
  59.         struct are_integral;
  60.     }
  61.  
  62.     /// INTERNAL ONLY
  63.     ///
  64. #define BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(Name, Op)                                     \
  65.     namespace functional                                                                        \
  66.     {                                                                                           \
  67.         template<typename Arg, typename EnableIf = void>                                        \
  68.         struct Name ## _base;                                                                   \
  69.         template<typename Arg, typename ArgTag = typename tag<Arg>::type>                       \
  70.         struct Name;                                                                            \
  71.     }                                                                                           \
  72.     namespace op                                                                                \
  73.     {                                                                                           \
  74.         struct Name;                                                                            \
  75.     }                                                                                           \
  76.     namespace                                                                                   \
  77.     {                                                                                           \
  78.         extern op::Name const &Name;                                                            \
  79.     }
  80.  
  81.     /// INTERNAL ONLY
  82.     ///
  83. #define BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(Name)                                        \
  84.     namespace functional                                                                        \
  85.     {                                                                                           \
  86.         template<typename Left, typename Right, typename EnableIf = void>                       \
  87.         struct result_of_ ## Name;                                                              \
  88.         template<typename Left, typename Right, typename EnableIf = void>                       \
  89.         struct Name ## _base;                                                                   \
  90.         template<                                                                               \
  91.             typename Left                                                                       \
  92.           , typename Right                                                                      \
  93.           , typename LeftTag = typename tag<Left>::type                                         \
  94.           , typename RightTag = typename tag<Right>::type                                       \
  95.         >                                                                                       \
  96.         struct Name;                                                                            \
  97.     }                                                                                           \
  98.     namespace op                                                                                \
  99.     {                                                                                           \
  100.         struct Name;                                                                            \
  101.     }                                                                                           \
  102.     namespace                                                                                   \
  103.     {                                                                                           \
  104.         extern op::Name const &Name;                                                            \
  105.     }
  106.  
  107.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus)
  108.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus)
  109.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies)
  110.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides)
  111.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus)
  112.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater)
  113.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(greater_equal)
  114.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less)
  115.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(less_equal)
  116.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(equal_to)
  117.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(not_equal_to)
  118.  
  119.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(assign)
  120.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(plus_assign)
  121.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(minus_assign)
  122.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(multiplies_assign)
  123.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(divides_assign)
  124.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP(modulus_assign)
  125.  
  126.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_plus, +)
  127.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(unary_minus, -)
  128.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(complement, ~)
  129.     BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP(logical_not, !)
  130.  
  131. #undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_UNARY_OP
  132. #undef BOOST_NUMERIC_FUNCTIONAL_DECLARE_BINARY_OP
  133.  
  134.  
  135.     namespace functional
  136.     {
  137.         template<typename To, typename From, typename EnableIf = void>
  138.         struct promote_base;
  139.         template<typename Left, typename Right, typename EnableIf = void>
  140.         struct min_assign_base;
  141.         template<typename Left, typename Right, typename EnableIf = void>
  142.         struct max_assign_base;
  143.         template<typename Left, typename Right, typename EnableIf = void>
  144.         struct fdiv_base;
  145.         template<typename Arg, typename EnableIf = void>
  146.         struct as_min_base;
  147.         template<typename Arg, typename EnableIf = void>
  148.         struct as_max_base;
  149.         template<typename Arg, typename EnableIf = void>
  150.         struct as_zero_base;
  151.         template<typename Arg, typename EnableIf = void>
  152.         struct as_one_base;
  153.  
  154.         template<typename To, typename From, typename ToTag = typename tag<To>::type, typename FromTag = typename tag<From>::type>
  155.         struct promote;
  156.         template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
  157.         struct min_assign;
  158.         template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
  159.         struct max_assign;
  160.         template<typename Left, typename Right, typename LeftTag = typename tag<Left>::type, typename RightTag = typename tag<Right>::type>
  161.         struct fdiv;
  162.         template<typename Arg, typename Tag = typename tag<Arg>::type>
  163.         struct as_min;
  164.         template<typename Arg, typename Tag = typename tag<Arg>::type>
  165.         struct as_max;
  166.         template<typename Arg, typename Tag = typename tag<Arg>::type>
  167.         struct as_zero;
  168.         template<typename Arg, typename Tag = typename tag<Arg>::type>
  169.         struct as_one;
  170.     }
  171.  
  172.     namespace op
  173.     {
  174.         template<typename To>
  175.         struct promote;
  176.         struct min_assign;
  177.         struct max_assign;
  178.         struct fdiv;
  179.         struct as_min;
  180.         struct as_max;
  181.         struct as_zero;
  182.         struct as_one;
  183.     }
  184.  
  185.     namespace
  186.     {
  187.         extern op::min_assign const &min_assign;
  188.         extern op::max_assign const &max_assign;
  189.         extern op::fdiv const &fdiv;
  190.         extern op::as_min const &as_min;
  191.         extern op::as_max const &as_max;
  192.         extern op::as_zero const &as_zero;
  193.         extern op::as_one const &as_one;
  194.     }
  195.  
  196.     template<typename To, typename From>
  197.     typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type
  198.     promote(From &from);
  199.  
  200.     template<typename To, typename From>
  201.     typename mpl::if_<is_same<To const, From const>, To const &, To const>::type
  202.     promote(From const &from);
  203.  
  204.     template<typename T>
  205.     struct default_;
  206.  
  207.     template<typename T>
  208.     struct one;
  209.  
  210.     template<typename T>
  211.     struct zero;
  212.  
  213.     template<typename T>
  214.     struct one_or_default;
  215.  
  216.     template<typename T>
  217.     struct zero_or_default;
  218.  
  219. }} // namespace mars_boost::numeric
  220.  
  221. #endif
  222.  
downloadfunctional_fwd.hpp Source code - Download mars Source code
Related Source Codes/Software:
Hero - Elegant transition library for iOS & tvOS 2017-06-09
deep-photo-styletransfer - Code and data for paper "Deep Photo Style Transfer... 2017-06-09
mastodon - A GNU Social-compatible microblogging server ... 2017-06-09
plyr - A simple HTML5, YouTube and Vimeo player ... 2017-06-08
prepack - Prepack is a partial evaluator for JavaScript. Pre... 2017-06-08
Public-APIs - 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
lectures - Oxford Deep NLP 2017 course 2017-06-10
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top