BVB Source Codes

mars Show functional.hpp Source code

Return Download mars: download functional.hpp Source code - Download mars Source code - Type:.hpp
  1. ///////////////////////////////////////////////////////////////////////////////
  2. /// \file functional.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_HPP_EAN_08_12_2005
  9. #define BOOST_NUMERIC_FUNCTIONAL_HPP_EAN_08_12_2005
  10.  
  11. #include <limits>
  12. #include <functional>
  13. #include <boost/static_assert.hpp>
  14. #include <boost/mpl/if.hpp>
  15. #include <boost/mpl/and.hpp>
  16. #include <boost/type_traits/remove_const.hpp>
  17. #include <boost/type_traits/add_reference.hpp>
  18. #include <boost/type_traits/is_empty.hpp>
  19. #include <boost/type_traits/is_integral.hpp>
  20. #include <boost/type_traits/is_floating_point.hpp>
  21. #include <boost/utility/enable_if.hpp>
  22. #include <boost/typeof/typeof.hpp>
  23. #include <boost/accumulators/accumulators_fwd.hpp>
  24. #include <boost/accumulators/numeric/functional_fwd.hpp>
  25. #include <boost/accumulators/numeric/detail/function1.hpp>
  26. #include <boost/accumulators/numeric/detail/function2.hpp>
  27. #include <boost/accumulators/numeric/detail/pod_singleton.hpp>
  28.  
  29. #ifdef BOOST_NUMERIC_FUNCTIONAL_STD_VECTOR_SUPPORT
  30. # include <boost/accumulators/numeric/functional/vector.hpp>
  31. #endif
  32.  
  33. #ifdef BOOST_NUMERIC_FUNCTIONAL_STD_VALARRAY_SUPPORT
  34. # include <boost/accumulators/numeric/functional/valarray.hpp>
  35. #endif
  36.  
  37. #ifdef BOOST_NUMERIC_FUNCTIONAL_STD_COMPLEX_SUPPORT
  38. # include <boost/accumulators/numeric/functional/complex.hpp>
  39. #endif
  40.  
  41. /// INTERNAL ONLY
  42. ///
  43. #define BOOST_NUMERIC_FUNCTIONAL_HPP_INCLUDED
  44.  
  45. #ifdef BOOST_NUMERIC_FUNCTIONAL_DOXYGEN_INVOKED
  46. // Hack to make Doxygen show the inheritance relationships
  47. /// INTERNAL ONLY
  48. ///
  49. namespace std
  50. {
  51.     /// INTERNAL ONLY
  52.     ///
  53.     template<class Arg, class Ret> struct unary_function {};
  54.     /// INTERNAL ONLY
  55.     ///
  56.     template<class Left, class Right, class Ret> struct binary_function {};
  57. }
  58. #endif
  59.  
  60. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost { namespace numeric
  61. {
  62.     namespace functional
  63.     {
  64.         /// INTERNAL ONLY
  65.         ///
  66.         template<typename A0, typename A1>
  67.         struct are_integral
  68.           : mpl::and_<is_integral<A0>, is_integral<A1> >
  69.         {};
  70.  
  71.         template<typename Left, typename Right>
  72.         struct left_ref
  73.         {
  74.             typedef Left &type;
  75.         };
  76.  
  77.         namespace detail
  78.         {
  79.             template<typename T>
  80.             T &lvalue_of();
  81.         }
  82.     }
  83.  
  84.     // TODO: handle complex weight, valarray, MTL vectors
  85.  
  86.     /// INTERNAL ONLY
  87.     ///
  88. #define BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(Name, Op)                                      \
  89.     namespace functional                                                                        \
  90.     {                                                                                           \
  91.         template<typename Arg>                                                                  \
  92.         struct result_of_ ## Name                                                               \
  93.         {                                                                                       \
  94.             BOOST_TYPEOF_NESTED_TYPEDEF_TPL(                                                    \
  95.                 nested                                                                          \
  96.               , Op mars_boost::numeric::functional::detail::lvalue_of<Arg>()                         \
  97.             )                                                                                   \
  98.             typedef typename nested::type type;                                                 \
  99.         };                                                                                      \
  100.         template<typename Arg, typename EnableIf>                                               \
  101.         struct Name ## _base                                                                    \
  102.           : std::unary_function<                                                                \
  103.                 typename remove_const<Arg>::type                                                \
  104.               , typename result_of_ ## Name<Arg>::type                                          \
  105.             >                                                                                   \
  106.         {                                                                                       \
  107.             typename result_of_ ## Name<Arg>::type operator ()(Arg &arg) const                  \
  108.             {                                                                                   \
  109.                 return Op arg;                                                                  \
  110.             }                                                                                   \
  111.         };                                                                                      \
  112.         template<typename Arg, typename ArgTag>                                                 \
  113.         struct Name                                                                             \
  114.           : Name ## _base<Arg, void>                                                            \
  115.         {};                                                                                     \
  116.     }                                                                                           \
  117.     namespace op                                                                                \
  118.     {                                                                                           \
  119.         struct Name                                                                             \
  120.           : mars_boost::detail::function1<functional::Name<_, functional::tag<_> > >                 \
  121.         {};                                                                                     \
  122.     }                                                                                           \
  123.     namespace                                                                                   \
  124.     {                                                                                           \
  125.         op::Name const &Name = mars_boost::detail::pod_singleton<op::Name>::instance;                \
  126.     }                                                                                           \
  127.     /**/
  128.  
  129.     /// INTERNAL ONLY
  130.     ///
  131. #define BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(Name, Op, RetType)                            \
  132.     namespace functional                                                                        \
  133.     {                                                                                           \
  134.         template<typename Left, typename Right, typename EnableIf>                              \
  135.         struct result_of_ ## Name                                                               \
  136.         {                                                                                       \
  137.             RetType(Left, Op, Right)                                                            \
  138.         };                                                                                      \
  139.         template<typename Left, typename Right, typename EnableIf>                              \
  140.         struct Name ## _base                                                                    \
  141.           : std::binary_function<                                                               \
  142.                 typename remove_const<Left>::type                                               \
  143.               , typename remove_const<Right>::type                                              \
  144.               , typename result_of_ ## Name<Left, Right>::type                                  \
  145.             >                                                                                   \
  146.         {                                                                                       \
  147.             typename result_of_ ## Name<Left, Right>::type                                      \
  148.             operator ()(Left &left, Right &right) const                                         \
  149.             {                                                                                   \
  150.                 return left Op right;                                                           \
  151.             }                                                                                   \
  152.         };                                                                                      \
  153.         template<typename Left, typename Right, typename LeftTag, typename RightTag>            \
  154.         struct Name                                                                             \
  155.           : Name ## _base<Left, Right, void>                                                    \
  156.         {};                                                                                     \
  157.     }                                                                                           \
  158.     namespace op                                                                                \
  159.     {                                                                                           \
  160.         struct Name                                                                             \
  161.           : mars_boost::detail::function2<                                                           \
  162.                 functional::Name<_1, _2, functional::tag<_1>, functional::tag<_2> >             \
  163.             >                                                                                   \
  164.         {};                                                                                     \
  165.     }                                                                                           \
  166.     namespace                                                                                   \
  167.     {                                                                                           \
  168.         op::Name const &Name = mars_boost::detail::pod_singleton<op::Name>::instance;                \
  169.     }                                                                                           \
  170.     BOOST_ACCUMULATORS_IGNORE_GLOBAL(Name)                                                      \
  171.     /**/
  172.  
  173.     /// INTERNAL ONLY
  174.     ///
  175. #define BOOST_NUMERIC_FUNCTIONAL_DEDUCED(Left, Op, Right)                                       \
  176.     BOOST_TYPEOF_NESTED_TYPEDEF_TPL(                                                            \
  177.         nested                                                                                  \
  178.       , mars_boost::numeric::functional::detail::lvalue_of<Left>() Op                                \
  179.         mars_boost::numeric::functional::detail::lvalue_of<Right>()                                  \
  180.     )                                                                                           \
  181.     typedef typename nested::type type;                                                         \
  182.     /**/
  183.  
  184.     /// INTERNAL ONLY
  185.     ///
  186. #define BOOST_NUMERIC_FUNCTIONAL_LEFT(Left, Op, Right)                                          \
  187.     typedef Left &type;                                                                         \
  188.     /**/
  189.  
  190.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus, +, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  191.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(minus, -, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  192.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies, *, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  193.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(divides, /, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  194.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus, %, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  195.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater, >, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  196.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(greater_equal, >=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  197.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(less, <, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  198.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(less_equal, <=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  199.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(equal_to, ==, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  200.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(not_equal_to, !=, BOOST_NUMERIC_FUNCTIONAL_DEDUCED)
  201.  
  202.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(assign, =, BOOST_NUMERIC_FUNCTIONAL_LEFT)
  203.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(plus_assign, +=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
  204.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(minus_assign, -=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
  205.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(multiplies_assign, *=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
  206.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(divides_assign, /=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
  207.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(modulus_assign, %=, BOOST_NUMERIC_FUNCTIONAL_LEFT)
  208.  
  209.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(unary_plus, +)
  210.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(unary_minus, -)
  211.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(complement, ~)
  212.     BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(logical_not, !)
  213.  
  214. #undef BOOST_NUMERIC_FUNCTIONAL_LEFT
  215. #undef BOOST_NUMERIC_FUNCTIONAL_DEDUCED
  216. #undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP
  217. #undef BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP
  218.  
  219.     namespace functional
  220.     {
  221.         template<typename Left, typename Right, typename EnableIf>
  222.         struct min_assign_base
  223.           : std::binary_function<Left, Right, void>
  224.         {
  225.             void operator ()(Left &left, Right &right) const
  226.             {
  227.                 if(numeric::less(right, left))
  228.                 {
  229.                     left = right;
  230.                 }
  231.             }
  232.         };
  233.  
  234.         template<typename Left, typename Right, typename EnableIf>
  235.         struct max_assign_base
  236.           : std::binary_function<Left, Right, void>
  237.         {
  238.             void operator ()(Left &left, Right &right) const
  239.             {
  240.                 if(numeric::greater(right, left))
  241.                 {
  242.                     left = right;
  243.                 }
  244.             }
  245.         };
  246.  
  247.         template<typename Left, typename Right, typename EnableIf>
  248.         struct fdiv_base
  249.           : functional::divides<Left, Right>
  250.         {};
  251.  
  252.         // partial specialization that promotes the arguments to double for
  253.         // integral division.
  254.         template<typename Left, typename Right>
  255.         struct fdiv_base<Left, Right, typename enable_if<are_integral<Left, Right> >::type>
  256.           : functional::divides<double const, double const>
  257.         {};
  258.  
  259.         template<typename To, typename From, typename EnableIf>
  260.         struct promote_base
  261.           : std::unary_function<From, To>
  262.         {
  263.             To operator ()(From &from) const
  264.             {
  265.                 return from;
  266.             }
  267.         };
  268.  
  269.         template<typename ToFrom>
  270.         struct promote_base<ToFrom, ToFrom, void>
  271.           : std::unary_function<ToFrom, ToFrom>
  272.         {
  273.             ToFrom &operator ()(ToFrom &tofrom)
  274.             {
  275.                 return tofrom;
  276.             }
  277.         };
  278.  
  279.         template<typename Arg, typename EnableIf>
  280.         struct as_min_base
  281.           : std::unary_function<Arg, typename remove_const<Arg>::type>
  282.         {
  283.             BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
  284.  
  285.             typename remove_const<Arg>::type operator ()(Arg &) const
  286.             {
  287.                 return (std::numeric_limits<typename remove_const<Arg>::type>::min)();
  288.             }
  289.         };
  290.  
  291.         template<typename Arg>
  292.         struct as_min_base<Arg, typename enable_if<is_floating_point<Arg> >::type>
  293.           : std::unary_function<Arg, typename remove_const<Arg>::type>
  294.         {
  295.             BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
  296.  
  297.             typename remove_const<Arg>::type operator ()(Arg &) const
  298.             {
  299.                 return -(std::numeric_limits<typename remove_const<Arg>::type>::max)();
  300.             }
  301.         };
  302.  
  303.         template<typename Arg, typename EnableIf>
  304.         struct as_max_base
  305.           : std::unary_function<Arg, typename remove_const<Arg>::type>
  306.         {
  307.             BOOST_STATIC_ASSERT(std::numeric_limits<typename remove_const<Arg>::type>::is_specialized);
  308.  
  309.             typename remove_const<Arg>::type operator ()(Arg &) const
  310.             {
  311.                 return (std::numeric_limits<typename remove_const<Arg>::type>::max)();
  312.             }
  313.         };
  314.  
  315.         template<typename Arg, typename EnableIf>
  316.         struct as_zero_base
  317.           : std::unary_function<Arg, typename remove_const<Arg>::type>
  318.         {
  319.             typename remove_const<Arg>::type operator ()(Arg &) const
  320.             {
  321.                 return numeric::zero<typename remove_const<Arg>::type>::value;
  322.             }
  323.         };
  324.  
  325.         template<typename Arg, typename EnableIf>
  326.         struct as_one_base
  327.           : std::unary_function<Arg, typename remove_const<Arg>::type>
  328.         {
  329.             typename remove_const<Arg>::type operator ()(Arg &) const
  330.             {
  331.                 return numeric::one<typename remove_const<Arg>::type>::value;
  332.             }
  333.         };
  334.  
  335.         template<typename To, typename From, typename ToTag, typename FromTag>
  336.         struct promote
  337.           : promote_base<To, From, void>
  338.         {};
  339.  
  340.         template<typename Left, typename Right, typename LeftTag, typename RightTag>
  341.         struct min_assign
  342.           : min_assign_base<Left, Right, void>
  343.         {};
  344.  
  345.         template<typename Left, typename Right, typename LeftTag, typename RightTag>
  346.         struct max_assign
  347.           : max_assign_base<Left, Right, void>
  348.         {};
  349.  
  350.         template<typename Left, typename Right, typename LeftTag, typename RightTag>
  351.         struct fdiv
  352.           : fdiv_base<Left, Right, void>
  353.         {};
  354.  
  355.         /// INTERNAL ONLY
  356.         /// For back-compat only. Use fdiv.
  357.         template<typename Left, typename Right, typename LeftTag, typename RightTag>
  358.         struct average
  359.           : fdiv<Left, Right, LeftTag, RightTag>
  360.         {};
  361.  
  362.         template<typename Arg, typename Tag>
  363.         struct as_min
  364.           : as_min_base<Arg, void>
  365.         {};
  366.  
  367.         template<typename Arg, typename Tag>
  368.         struct as_max
  369.           : as_max_base<Arg, void>
  370.         {};
  371.  
  372.         template<typename Arg, typename Tag>
  373.         struct as_zero
  374.           : as_zero_base<Arg, void>
  375.         {};
  376.  
  377.         template<typename Arg, typename Tag>
  378.         struct as_one
  379.           : as_one_base<Arg, void>
  380.         {};
  381.     }
  382.  
  383.     namespace op
  384.     {
  385.         template<typename To>
  386.         struct promote
  387.           : mars_boost::detail::function1<functional::promote<To, _, typename functional::tag<To>::type, functional::tag<_> > >
  388.         {};
  389.  
  390.         struct min_assign
  391.           : mars_boost::detail::function2<functional::min_assign<_1, _2, functional::tag<_1>, functional::tag<_2> > >
  392.         {};
  393.  
  394.         struct max_assign
  395.           : mars_boost::detail::function2<functional::max_assign<_1, _2, functional::tag<_1>, functional::tag<_2> > >
  396.         {};
  397.  
  398.         struct fdiv
  399.           : mars_boost::detail::function2<functional::fdiv<_1, _2, functional::tag<_1>, functional::tag<_2> > >
  400.         {};
  401.  
  402.         /// INTERNAL ONLY
  403.         struct average
  404.           : mars_boost::detail::function2<functional::fdiv<_1, _2, functional::tag<_1>, functional::tag<_2> > >
  405.         {};
  406.  
  407.         struct as_min
  408.           : mars_boost::detail::function1<functional::as_min<_, functional::tag<_> > >
  409.         {};
  410.  
  411.         struct as_max
  412.           : mars_boost::detail::function1<functional::as_max<_, functional::tag<_> > >
  413.         {};
  414.  
  415.         struct as_zero
  416.           : mars_boost::detail::function1<functional::as_zero<_, functional::tag<_> > >
  417.         {};
  418.  
  419.         struct as_one
  420.           : mars_boost::detail::function1<functional::as_one<_, functional::tag<_> > >
  421.         {};
  422.     }
  423.  
  424.     namespace
  425.     {
  426.         op::min_assign const &min_assign = mars_boost::detail::pod_singleton<op::min_assign>::instance;
  427.         op::max_assign const &max_assign = mars_boost::detail::pod_singleton<op::max_assign>::instance;
  428.         op::fdiv const &fdiv = mars_boost::detail::pod_singleton<op::fdiv>::instance;
  429.         op::fdiv const &average = mars_boost::detail::pod_singleton<op::fdiv>::instance; ///< INTERNAL ONLY
  430.         op::as_min const &as_min = mars_boost::detail::pod_singleton<op::as_min>::instance;
  431.         op::as_max const &as_max = mars_boost::detail::pod_singleton<op::as_max>::instance;
  432.         op::as_zero const &as_zero = mars_boost::detail::pod_singleton<op::as_zero>::instance;
  433.         op::as_one const &as_one = mars_boost::detail::pod_singleton<op::as_one>::instance;
  434.  
  435.         BOOST_ACCUMULATORS_IGNORE_GLOBAL(min_assign)
  436.         BOOST_ACCUMULATORS_IGNORE_GLOBAL(max_assign)
  437.         BOOST_ACCUMULATORS_IGNORE_GLOBAL(fdiv)
  438.         BOOST_ACCUMULATORS_IGNORE_GLOBAL(average)
  439.         BOOST_ACCUMULATORS_IGNORE_GLOBAL(as_min)
  440.         BOOST_ACCUMULATORS_IGNORE_GLOBAL(as_max)
  441.         BOOST_ACCUMULATORS_IGNORE_GLOBAL(as_zero)
  442.         BOOST_ACCUMULATORS_IGNORE_GLOBAL(as_one)
  443.     }
  444.  
  445.     ///////////////////////////////////////////////////////////////////////////////
  446.     // promote
  447.     template<typename To, typename From>
  448.     typename lazy_disable_if<is_const<From>, mpl::if_<is_same<To, From>, To &, To> >::type
  449.     promote(From &from)
  450.     {
  451.         return functional::promote<To, From>()(from);
  452.     }
  453.  
  454.     template<typename To, typename From>
  455.     typename mpl::if_<is_same<To const, From const>, To const &, To const>::type
  456.     promote(From const &from)
  457.     {
  458.         return functional::promote<To const, From const>()(from);
  459.     }
  460.  
  461.     template<typename T>
  462.     struct default_
  463.     {
  464.         typedef default_ type;
  465.         typedef T value_type;
  466.         static T const value;
  467.  
  468.         operator T const & () const
  469.         {
  470.             return default_::value;
  471.         }
  472.     };
  473.  
  474.     template<typename T>
  475.     T const default_<T>::value = T();
  476.  
  477.     template<typename T>
  478.     struct one
  479.     {
  480.         typedef one type;
  481.         typedef T value_type;
  482.         static T const value;
  483.  
  484.         operator T const & () const
  485.         {
  486.             return one::value;
  487.         }
  488.     };
  489.  
  490.     template<typename T>
  491.     T const one<T>::value = T(1);
  492.  
  493.     template<typename T>
  494.     struct zero
  495.     {
  496.         typedef zero type;
  497.         typedef T value_type;
  498.         static T const value;
  499.  
  500.         operator T const & () const
  501.         {
  502.             return zero::value;
  503.         }
  504.     };
  505.  
  506.     template<typename T>
  507.     T const zero<T>::value = T();
  508.  
  509.     template<typename T>
  510.     struct one_or_default
  511.       : mpl::if_<is_empty<T>, default_<T>, one<T> >::type
  512.     {};
  513.  
  514.     template<typename T>
  515.     struct zero_or_default
  516.       : mpl::if_<is_empty<T>, default_<T>, zero<T> >::type
  517.     {};
  518.  
  519. }} // namespace mars_boost::numeric
  520.  
  521. #endif
  522.  
downloadfunctional.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