BVB Source Codes

mars Show copy_move_algo.hpp Source code

Return Download mars: download copy_move_algo.hpp Source code - Download mars Source code - Type:.hpp
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. // (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
  4. // Software License, Version 1.0. (See accompanying file
  5. // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  6. //
  7. // See http://www.boost.org/libs/container for documentation.
  8. //
  9. //////////////////////////////////////////////////////////////////////////////
  10. #ifndef BOOST_CONTAINER_DETAIL_UTILITIES_HPP
  11. #define BOOST_CONTAINER_DETAIL_UTILITIES_HPP
  12.  
  13. #ifndef BOOST_CONFIG_HPP
  14. #  include <boost/config.hpp>
  15. #endif
  16.  
  17. #if defined(BOOST_HAS_PRAGMA_ONCE)
  18. #  pragma once
  19. #endif
  20.  
  21. // container
  22. #include <boost/container/allocator_traits.hpp>
  23. // container/detail
  24. #include <boost/container/detail/iterator.hpp>
  25. #include <boost/container/detail/iterator_to_raw_pointer.hpp>
  26. #include <boost/container/detail/mpl.hpp>
  27. #include <boost/container/detail/type_traits.hpp>
  28. // move
  29. #include <boost/move/adl_move_swap.hpp>
  30. #include <boost/move/iterator.hpp>
  31. #include <boost/move/utility_core.hpp>
  32. // other
  33. #include <boost/core/no_exceptions_support.hpp>
  34. // std
  35. #include <cstring> //for emmove/memcpy
  36.  
  37. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  38. namespace container {
  39. namespace container_detail {
  40.  
  41. template<class I>
  42. struct are_elements_contiguous
  43. {
  44.    static const bool value = false;
  45. };
  46.  
  47. /////////////////////////
  48. //    raw pointers
  49. /////////////////////////
  50.  
  51. template<class T>
  52. struct are_elements_contiguous<T*>
  53. {
  54.    static const bool value = true;
  55. };
  56.  
  57. /////////////////////////
  58. //    move iterators
  59. /////////////////////////
  60.  
  61. template<class It>
  62. struct are_elements_contiguous< ::mars_boost::move_iterator<It> >
  63.    : are_elements_contiguous<It>
  64. {};
  65.  
  66. /////////////////////////
  67. //    predeclarations
  68. /////////////////////////
  69.  
  70. #ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
  71.  
  72. template<class Pointer>
  73. class vector_iterator;
  74.  
  75. template<class Pointer>
  76. class vector_const_iterator;
  77.  
  78. #endif   //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
  79.  
  80. }  //namespace container_detail {
  81. }  //namespace container {
  82.  
  83. namespace interprocess {
  84.  
  85. template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
  86. class offset_ptr;
  87.  
  88. }  //namespace interprocess {
  89.  
  90. namespace container {
  91.  
  92. namespace container_detail {
  93.  
  94. /////////////////////////
  95. //vector_[const_]iterator
  96. /////////////////////////
  97.  
  98. #ifndef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
  99.  
  100. template<class Pointer>
  101. struct are_elements_contiguous<mars_boost::container::container_detail::vector_iterator<Pointer> >
  102. {
  103.    static const bool value = true;
  104. };
  105.  
  106. template<class Pointer>
  107. struct are_elements_contiguous<mars_boost::container::container_detail::vector_const_iterator<Pointer> >
  108. {
  109.    static const bool value = true;
  110. };
  111.  
  112. #endif   //BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
  113.  
  114. /////////////////////////
  115. //    offset_ptr
  116. /////////////////////////
  117.  
  118. template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
  119. struct are_elements_contiguous< ::mars_boost::interprocess::offset_ptr<PointedType, DifferenceType, OffsetType, OffsetAlignment> >
  120. {
  121.    static const bool value = true;
  122. };
  123.  
  124. template <typename I, typename O>
  125. struct are_contiguous_and_same
  126.    : mars_boost::move_detail::and_
  127.       < are_elements_contiguous<I>
  128.       , are_elements_contiguous<O>
  129.       , is_same< typename remove_const< typename ::mars_boost::container::iterator_traits<I>::value_type >::type
  130.                , typename ::mars_boost::container::iterator_traits<O>::value_type
  131.                >
  132.       >
  133. {};
  134.  
  135. template <typename I, typename O>
  136. struct is_memtransfer_copy_assignable
  137.    : mars_boost::move_detail::and_
  138.       < are_contiguous_and_same<I, O>
  139.       , container_detail::is_trivially_copy_assignable< typename ::mars_boost::container::iterator_traits<I>::value_type >
  140.       >
  141. {};
  142.  
  143. template <typename I, typename O>
  144. struct is_memtransfer_copy_constructible
  145.    : mars_boost::move_detail::and_
  146.       < are_contiguous_and_same<I, O>
  147.       , container_detail::is_trivially_copy_constructible< typename ::mars_boost::container::iterator_traits<I>::value_type >
  148.       >
  149. {};
  150.  
  151. template <typename I, typename O, typename R>
  152. struct enable_if_memtransfer_copy_constructible
  153.    : enable_if<container_detail::is_memtransfer_copy_constructible<I, O>, R>
  154. {};
  155.  
  156. template <typename I, typename O, typename R>
  157. struct disable_if_memtransfer_copy_constructible
  158.    : disable_if<container_detail::is_memtransfer_copy_constructible<I, O>, R>
  159. {};
  160.  
  161. template <typename I, typename O, typename R>
  162. struct enable_if_memtransfer_copy_assignable
  163.    : enable_if<container_detail::is_memtransfer_copy_assignable<I, O>, R>
  164. {};
  165.  
  166. template <typename I, typename O, typename R>
  167. struct disable_if_memtransfer_copy_assignable
  168.    : disable_if<container_detail::is_memtransfer_copy_assignable<I, O>, R>
  169. {};
  170.  
  171. template
  172.    <typename I, // I models InputIterator
  173.     typename F> // F models ForwardIterator
  174. inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
  175. {
  176.    typedef typename mars_boost::container::iterator_traits<I>::value_type value_type;
  177.    typename mars_boost::container::iterator_traits<I>::difference_type n = mars_boost::container::iterator_distance(f, l);
  178.    if(n){
  179.       std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
  180.       mars_boost::container::iterator_advance(r, n);
  181.    }
  182.    return r;
  183. }
  184.  
  185. template
  186.    <typename I, // I models InputIterator
  187.     typename F> // F models ForwardIterator
  188. F memmove_n(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  189. {
  190.    typedef typename mars_boost::container::iterator_traits<I>::value_type value_type;
  191.    if(n){
  192.       std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
  193.       mars_boost::container::iterator_advance(r, n);
  194.    }
  195.    return r;
  196. }
  197.  
  198. template
  199.    <typename I, // I models InputIterator
  200.     typename F> // F models ForwardIterator
  201. I memmove_n_source(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  202. {
  203.    if(n){
  204.       typedef typename mars_boost::container::iterator_traits<I>::value_type value_type;
  205.       std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
  206.       mars_boost::container::iterator_advance(f, n);
  207.    }
  208.    return f;
  209. }
  210.  
  211. template
  212.    <typename I, // I models InputIterator
  213.     typename F> // F models ForwardIterator
  214. I memmove_n_source_dest(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
  215. {
  216.    typedef typename mars_boost::container::iterator_traits<I>::value_type value_type;
  217.    if(n){
  218.       std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
  219.       mars_boost::container::iterator_advance(f, n);
  220.       mars_boost::container::iterator_advance(r, n);
  221.    }
  222.    return f;
  223. }
  224.  
  225. template <typename O>
  226. struct is_memzero_initializable
  227. {
  228.    typedef typename ::mars_boost::container::iterator_traits<O>::value_type value_type;
  229.    static const bool value = are_elements_contiguous<O>::value &&
  230.       (  container_detail::is_integral<value_type>::value || container_detail::is_enum<value_type>::value
  231.       #if defined(BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL)
  232.       || container_detail::is_pointer<value_type>::value
  233.       #endif
  234.       #if defined(BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO)
  235.       || container_detail::is_floating_point<value_type>::value
  236.       #endif
  237.       #if defined(BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO) && defined(BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL)
  238.       || container_detail::is_pod<value_type>::value
  239.       #endif
  240.       );
  241. };
  242.  
  243. template <typename O, typename R>
  244. struct enable_if_memzero_initializable
  245.    : enable_if_c<container_detail::is_memzero_initializable<O>::value, R>
  246. {};
  247.  
  248. template <typename O, typename R>
  249. struct disable_if_memzero_initializable
  250.    : enable_if_c<!container_detail::is_memzero_initializable<O>::value, R>
  251. {};
  252.  
  253. template <typename I, typename R>
  254. struct enable_if_trivially_destructible
  255.    : enable_if_c < container_detail::is_trivially_destructible
  256.                   <typename mars_boost::container::iterator_traits<I>::value_type>::value
  257.                , R>
  258. {};
  259.  
  260. template <typename I, typename R>
  261. struct disable_if_trivially_destructible
  262.    : enable_if_c <!container_detail::is_trivially_destructible
  263.                   <typename mars_boost::container::iterator_traits<I>::value_type>::value
  264.                , R>
  265. {};
  266.  
  267. }  //namespace container_detail {
  268.  
  269. //////////////////////////////////////////////////////////////////////////////
  270. //
  271. //                               uninitialized_move_alloc
  272. //
  273. //////////////////////////////////////////////////////////////////////////////
  274.  
  275.  
  276. //! <b>Effects</b>:
  277. //!   \code
  278. //!   for (; f != l; ++r, ++f)
  279. //!      allocator_traits::construct(a, &*r, mars_boost::move(*f));
  280. //!   \endcode
  281. //!
  282. //! <b>Returns</b>: r
  283. template
  284.    <typename Allocator,
  285.     typename I, // I models InputIterator
  286.     typename F> // F models ForwardIterator
  287. inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
  288.    uninitialized_move_alloc(Allocator &a, I f, I l, F r)
  289. {
  290.    F back = r;
  291.    BOOST_TRY{
  292.       while (f != l) {
  293.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), mars_boost::move(*f));
  294.          ++f; ++r;
  295.       }
  296.    }
  297.    BOOST_CATCH(...){
  298.       for (; back != r; ++back){
  299.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  300.       }
  301.       BOOST_RETHROW;
  302.    }
  303.    BOOST_CATCH_END
  304.    return r;
  305. }
  306.  
  307. template
  308.    <typename Allocator,
  309.     typename I, // I models InputIterator
  310.     typename F> // F models ForwardIterator
  311. inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
  312.    uninitialized_move_alloc(Allocator &, I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
  313. {  return container_detail::memmove(f, l, r); }
  314.  
  315. //////////////////////////////////////////////////////////////////////////////
  316. //
  317. //                               uninitialized_move_alloc_n
  318. //
  319. //////////////////////////////////////////////////////////////////////////////
  320.  
  321. //! <b>Effects</b>:
  322. //!   \code
  323. //!   for (; n--; ++r, ++f)
  324. //!      allocator_traits::construct(a, &*r, mars_boost::move(*f));
  325. //!   \endcode
  326. //!
  327. //! <b>Returns</b>: r
  328. template
  329.    <typename Allocator,
  330.     typename I, // I models InputIterator
  331.     typename F> // F models ForwardIterator
  332. inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
  333.    uninitialized_move_alloc_n(Allocator &a, I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r)
  334. {
  335.    F back = r;
  336.    BOOST_TRY{
  337.       while (n--) {
  338.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), mars_boost::move(*f));
  339.          ++f; ++r;
  340.       }
  341.    }
  342.    BOOST_CATCH(...){
  343.       for (; back != r; ++back){
  344.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  345.       }
  346.       BOOST_RETHROW;
  347.    }
  348.    BOOST_CATCH_END
  349.    return r;
  350. }
  351.  
  352. template
  353.    <typename Allocator,
  354.     typename I, // I models InputIterator
  355.     typename F> // F models ForwardIterator
  356. inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
  357.    uninitialized_move_alloc_n(Allocator &, I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  358. {  return container_detail::memmove_n(f, n, r); }
  359.  
  360. //////////////////////////////////////////////////////////////////////////////
  361. //
  362. //                               uninitialized_move_alloc_n_source
  363. //
  364. //////////////////////////////////////////////////////////////////////////////
  365.  
  366. //! <b>Effects</b>:
  367. //!   \code
  368. //!   for (; n--; ++r, ++f)
  369. //!      allocator_traits::construct(a, &*r, mars_boost::move(*f));
  370. //!   \endcode
  371. //!
  372. //! <b>Returns</b>: f (after incremented)
  373. template
  374.    <typename Allocator,
  375.     typename I, // I models InputIterator
  376.     typename F> // F models ForwardIterator
  377. inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, I>::type
  378.    uninitialized_move_alloc_n_source(Allocator &a, I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r)
  379. {
  380.    F back = r;
  381.    BOOST_TRY{
  382.       while (n--) {
  383.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), mars_boost::move(*f));
  384.          ++f; ++r;
  385.       }
  386.    }
  387.    BOOST_CATCH(...){
  388.       for (; back != r; ++back){
  389.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  390.       }
  391.       BOOST_RETHROW;
  392.    }
  393.    BOOST_CATCH_END
  394.    return f;
  395. }
  396.  
  397. template
  398.    <typename Allocator,
  399.     typename I, // I models InputIterator
  400.     typename F> // F models ForwardIterator
  401. inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, I>::type
  402.    uninitialized_move_alloc_n_source(Allocator &, I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  403. {  return container_detail::memmove_n_source(f, n, r); }
  404.  
  405. //////////////////////////////////////////////////////////////////////////////
  406. //
  407. //                               uninitialized_copy_alloc
  408. //
  409. //////////////////////////////////////////////////////////////////////////////
  410.  
  411. //! <b>Effects</b>:
  412. //!   \code
  413. //!   for (; f != l; ++r, ++f)
  414. //!      allocator_traits::construct(a, &*r, *f);
  415. //!   \endcode
  416. //!
  417. //! <b>Returns</b>: r
  418. template
  419.    <typename Allocator,
  420.     typename I, // I models InputIterator
  421.     typename F> // F models ForwardIterator
  422. inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
  423.    uninitialized_copy_alloc(Allocator &a, I f, I l, F r)
  424. {
  425.    F back = r;
  426.    BOOST_TRY{
  427.       while (f != l) {
  428.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
  429.          ++f; ++r;
  430.       }
  431.    }
  432.    BOOST_CATCH(...){
  433.       for (; back != r; ++back){
  434.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  435.       }
  436.       BOOST_RETHROW;
  437.    }
  438.    BOOST_CATCH_END
  439.    return r;
  440. }
  441.  
  442. template
  443.    <typename Allocator,
  444.     typename I, // I models InputIterator
  445.     typename F> // F models ForwardIterator
  446. inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
  447.    uninitialized_copy_alloc(Allocator &, I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
  448. {  return container_detail::memmove(f, l, r); }
  449.  
  450. //////////////////////////////////////////////////////////////////////////////
  451. //
  452. //                               uninitialized_copy_alloc_n
  453. //
  454. //////////////////////////////////////////////////////////////////////////////
  455.  
  456. //! <b>Effects</b>:
  457. //!   \code
  458. //!   for (; n--; ++r, ++f)
  459. //!      allocator_traits::construct(a, &*r, *f);
  460. //!   \endcode
  461. //!
  462. //! <b>Returns</b>: r
  463. template
  464.    <typename Allocator,
  465.     typename I, // I models InputIterator
  466.     typename F> // F models ForwardIterator
  467. inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
  468.    uninitialized_copy_alloc_n(Allocator &a, I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r)
  469. {
  470.    F back = r;
  471.    BOOST_TRY{
  472.       while (n--) {
  473.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
  474.          ++f; ++r;
  475.       }
  476.    }
  477.    BOOST_CATCH(...){
  478.       for (; back != r; ++back){
  479.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  480.       }
  481.       BOOST_RETHROW;
  482.    }
  483.    BOOST_CATCH_END
  484.    return r;
  485. }
  486.  
  487. template
  488.    <typename Allocator,
  489.     typename I, // I models InputIterator
  490.     typename F> // F models ForwardIterator
  491. inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
  492.    uninitialized_copy_alloc_n(Allocator &, I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  493. {  return container_detail::memmove_n(f, n, r); }
  494.  
  495. //////////////////////////////////////////////////////////////////////////////
  496. //
  497. //                               uninitialized_copy_alloc_n_source
  498. //
  499. //////////////////////////////////////////////////////////////////////////////
  500.  
  501. //! <b>Effects</b>:
  502. //!   \code
  503. //!   for (; n--; ++r, ++f)
  504. //!      allocator_traits::construct(a, &*r, *f);
  505. //!   \endcode
  506. //!
  507. //! <b>Returns</b>: f (after incremented)
  508. template
  509.    <typename Allocator,
  510.     typename I, // I models InputIterator
  511.     typename F> // F models ForwardIterator
  512. inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, I>::type
  513.    uninitialized_copy_alloc_n_source(Allocator &a, I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r)
  514. {
  515.    F back = r;
  516.    BOOST_TRY{
  517.       while (n--) {
  518.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
  519.          ++f; ++r;
  520.       }
  521.    }
  522.    BOOST_CATCH(...){
  523.       for (; back != r; ++back){
  524.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  525.       }
  526.       BOOST_RETHROW;
  527.    }
  528.    BOOST_CATCH_END
  529.    return f;
  530. }
  531.  
  532. template
  533.    <typename Allocator,
  534.     typename I, // I models InputIterator
  535.     typename F> // F models ForwardIterator
  536. inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, I>::type
  537.    uninitialized_copy_alloc_n_source(Allocator &, I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  538. {  return container_detail::memmove_n_source(f, n, r); }
  539.  
  540. //////////////////////////////////////////////////////////////////////////////
  541. //
  542. //                               uninitialized_value_init_alloc_n
  543. //
  544. //////////////////////////////////////////////////////////////////////////////
  545.  
  546. //! <b>Effects</b>:
  547. //!   \code
  548. //!   for (; n--; ++r, ++f)
  549. //!      allocator_traits::construct(a, &*r);
  550. //!   \endcode
  551. //!
  552. //! <b>Returns</b>: r
  553. template
  554.    <typename Allocator,
  555.     typename F> // F models ForwardIterator
  556. inline typename container_detail::disable_if_memzero_initializable<F, F>::type
  557.    uninitialized_value_init_alloc_n(Allocator &a, typename allocator_traits<Allocator>::difference_type n, F r)
  558. {
  559.    F back = r;
  560.    BOOST_TRY{
  561.       while (n--) {
  562.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r));
  563.          ++r;
  564.       }
  565.    }
  566.    BOOST_CATCH(...){
  567.       for (; back != r; ++back){
  568.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  569.       }
  570.       BOOST_RETHROW;
  571.    }
  572.    BOOST_CATCH_END
  573.    return r;
  574. }
  575.  
  576. template
  577.    <typename Allocator,
  578.     typename F> // F models ForwardIterator
  579. inline typename container_detail::enable_if_memzero_initializable<F, F>::type
  580.    uninitialized_value_init_alloc_n(Allocator &, typename allocator_traits<Allocator>::difference_type n, F r)
  581. {
  582.    typedef typename mars_boost::container::iterator_traits<F>::value_type value_type;
  583.    std::memset((void*)container_detail::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
  584.    mars_boost::container::iterator_advance(r, n);
  585.    return r;
  586. }
  587.  
  588. //////////////////////////////////////////////////////////////////////////////
  589. //
  590. //                               uninitialized_default_init_alloc_n
  591. //
  592. //////////////////////////////////////////////////////////////////////////////
  593.  
  594. //! <b>Effects</b>:
  595. //!   \code
  596. //!   for (; n--; ++r, ++f)
  597. //!      allocator_traits::construct(a, &*r);
  598. //!   \endcode
  599. //!
  600. //! <b>Returns</b>: r
  601. template
  602.    <typename Allocator,
  603.     typename F> // F models ForwardIterator
  604. inline F uninitialized_default_init_alloc_n(Allocator &a, typename allocator_traits<Allocator>::difference_type n, F r)
  605. {
  606.    F back = r;
  607.    BOOST_TRY{
  608.       while (n--) {
  609.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), default_init);
  610.          ++r;
  611.       }
  612.    }
  613.    BOOST_CATCH(...){
  614.       for (; back != r; ++back){
  615.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  616.       }
  617.       BOOST_RETHROW;
  618.    }
  619.    BOOST_CATCH_END
  620.    return r;
  621. }
  622.  
  623. //////////////////////////////////////////////////////////////////////////////
  624. //
  625. //                               uninitialized_fill_alloc
  626. //
  627. //////////////////////////////////////////////////////////////////////////////
  628.  
  629. //! <b>Effects</b>:
  630. //!   \code
  631. //!   for (; f != l; ++r, ++f)
  632. //!      allocator_traits::construct(a, &*r, *f);
  633. //!   \endcode
  634. //!
  635. //! <b>Returns</b>: r
  636. template
  637.    <typename Allocator,
  638.     typename F, // F models ForwardIterator
  639.     typename T>
  640. inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t)
  641. {
  642.    F back = f;
  643.    BOOST_TRY{
  644.       while (f != l) {
  645.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(f), t);
  646.          ++f;
  647.       }
  648.    }
  649.    BOOST_CATCH(...){
  650.       for (; back != l; ++back){
  651.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  652.       }
  653.       BOOST_RETHROW;
  654.    }
  655.    BOOST_CATCH_END
  656. }
  657.  
  658.  
  659. //////////////////////////////////////////////////////////////////////////////
  660. //
  661. //                               uninitialized_fill_alloc_n
  662. //
  663. //////////////////////////////////////////////////////////////////////////////
  664.  
  665. //! <b>Effects</b>:
  666. //!   \code
  667. //!   for (; n--; ++r, ++f)
  668. //!      allocator_traits::construct(a, &*r, v);
  669. //!   \endcode
  670. //!
  671. //! <b>Returns</b>: r
  672. template
  673.    <typename Allocator,
  674.     typename T,
  675.     typename F> // F models ForwardIterator
  676. inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, typename allocator_traits<Allocator>::difference_type n, F r)
  677. {
  678.    F back = r;
  679.    BOOST_TRY{
  680.       while (n--) {
  681.          allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), v);
  682.          ++r;
  683.       }
  684.    }
  685.    BOOST_CATCH(...){
  686.       for (; back != r; ++back){
  687.          allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
  688.       }
  689.       BOOST_RETHROW;
  690.    }
  691.    BOOST_CATCH_END
  692.    return r;
  693. }
  694.  
  695. //////////////////////////////////////////////////////////////////////////////
  696. //
  697. //                               copy
  698. //
  699. //////////////////////////////////////////////////////////////////////////////
  700.  
  701. template
  702. <typename I,   // I models InputIterator
  703. typename F>    // F models ForwardIterator
  704. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
  705.    copy(I f, I l, F r)
  706. {
  707.    while (f != l) {
  708.       *r = *f;
  709.       ++f; ++r;
  710.    }
  711.    return r;
  712. }
  713.  
  714. template
  715. <typename I,   // I models InputIterator
  716. typename F>    // F models ForwardIterator
  717. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
  718.    copy(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
  719. {  return container_detail::memmove(f, l, r); }
  720.  
  721. //////////////////////////////////////////////////////////////////////////////
  722. //
  723. //                               copy_n
  724. //
  725. //////////////////////////////////////////////////////////////////////////////
  726.  
  727. template
  728. <typename I,   // I models InputIterator
  729. typename F>   // F models ForwardIterator
  730. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
  731.    copy_n(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r)
  732. {
  733.    while (n--) {
  734.       *r = *f;
  735.       ++f; ++r;
  736.    }
  737.    return r;
  738. }
  739.  
  740. template
  741. <typename I,   // I models InputIterator
  742. typename F>   // F models ForwardIterator
  743. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
  744.    copy_n(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  745. {  return container_detail::memmove_n(f, n, r); }
  746.  
  747. //////////////////////////////////////////////////////////////////////////////
  748. //
  749. //                            copy_n_source
  750. //
  751. //////////////////////////////////////////////////////////////////////////////
  752.  
  753. template
  754. <typename I,   // I models InputIterator
  755. typename F>   // F models ForwardIterator
  756. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
  757.    copy_n_source(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r)
  758. {
  759.    while (n--) {
  760.       *r = *f;
  761.       ++f; ++r;
  762.    }
  763.    return f;
  764. }
  765.  
  766. template
  767. <typename I,   // I models InputIterator
  768. typename F>   // F models ForwardIterator
  769. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
  770.    copy_n_source(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  771. {  return container_detail::memmove_n_source(f, n, r); }
  772.  
  773. //////////////////////////////////////////////////////////////////////////////
  774. //
  775. //                            copy_n_source_dest
  776. //
  777. //////////////////////////////////////////////////////////////////////////////
  778.  
  779. template
  780. <typename I,   // I models InputIterator
  781. typename F>   // F models ForwardIterator
  782. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
  783.    copy_n_source_dest(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F &r)
  784. {
  785.    while (n--) {
  786.       *r = *f;
  787.       ++f; ++r;
  788.    }
  789.    return f;
  790. }
  791.  
  792. template
  793. <typename I,   // I models InputIterator
  794. typename F>   // F models ForwardIterator
  795. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
  796.    copy_n_source_dest(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
  797. {  return container_detail::memmove_n_source_dest(f, n, r);  }
  798.  
  799. //////////////////////////////////////////////////////////////////////////////
  800. //
  801. //                         move
  802. //
  803. //////////////////////////////////////////////////////////////////////////////
  804.  
  805. template
  806. <typename I,   // I models InputIterator
  807. typename F>   // F models ForwardIterator
  808. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
  809.    move(I f, I l, F r)
  810. {
  811.    while (f != l) {
  812.       *r = ::mars_boost::move(*f);
  813.       ++f; ++r;
  814.    }
  815.    return r;
  816. }
  817.  
  818. template
  819. <typename I,   // I models InputIterator
  820. typename F>   // F models ForwardIterator
  821. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
  822.    move(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
  823. {  return container_detail::memmove(f, l, r); }
  824.  
  825. //////////////////////////////////////////////////////////////////////////////
  826. //
  827. //                         move_n
  828. //
  829. //////////////////////////////////////////////////////////////////////////////
  830.  
  831. template
  832. <typename I,   // I models InputIterator
  833. typename F>   // F models ForwardIterator
  834. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
  835.    move_n(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r)
  836. {
  837.    while (n--) {
  838.       *r = ::mars_boost::move(*f);
  839.       ++f; ++r;
  840.    }
  841.    return r;
  842. }
  843.  
  844. template
  845. <typename I,   // I models InputIterator
  846. typename F>   // F models ForwardIterator
  847. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
  848.    move_n(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  849. {  return container_detail::memmove_n(f, n, r); }
  850.  
  851.  
  852. //////////////////////////////////////////////////////////////////////////////
  853. //
  854. //                         move_backward
  855. //
  856. //////////////////////////////////////////////////////////////////////////////
  857.  
  858. template
  859. <typename I,   // I models BidirectionalIterator
  860. typename F>    // F models ForwardIterator
  861. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
  862.    move_backward(I f, I l, F r)
  863. {
  864.    while (f != l) {
  865.       --l; --r;
  866.       *r = ::mars_boost::move(*l);
  867.    }
  868.    return r;
  869. }
  870.  
  871. template
  872. <typename I,   // I models InputIterator
  873. typename F>   // F models ForwardIterator
  874. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
  875.    move_backward(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
  876. {
  877.    typedef typename mars_boost::container::iterator_traits<I>::value_type value_type;
  878.    const typename mars_boost::container::iterator_traits<I>::difference_type n = mars_boost::container::iterator_distance(f, l);
  879.    r -= n;
  880.    std::memmove((container_detail::iterator_to_raw_pointer)(r), (container_detail::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
  881.    return r;
  882. }
  883.  
  884. //////////////////////////////////////////////////////////////////////////////
  885. //
  886. //                         move_n_source_dest
  887. //
  888. //////////////////////////////////////////////////////////////////////////////
  889.  
  890. template
  891. <typename I    // I models InputIterator
  892. ,typename F>   // F models ForwardIterator
  893. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
  894.    move_n_source_dest(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F &r)
  895. {
  896.    while (n--) {
  897.       *r = ::mars_boost::move(*f);
  898.       ++f; ++r;
  899.    }
  900.    return f;
  901. }
  902.  
  903. template
  904. <typename I    // I models InputIterator
  905. ,typename F>   // F models ForwardIterator
  906. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
  907.    move_n_source_dest(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
  908. {  return container_detail::memmove_n_source_dest(f, n, r); }
  909.  
  910. //////////////////////////////////////////////////////////////////////////////
  911. //
  912. //                         move_n_source
  913. //
  914. //////////////////////////////////////////////////////////////////////////////
  915.  
  916. template
  917. <typename I    // I models InputIterator
  918. ,typename F>   // F models ForwardIterator
  919. inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
  920.    move_n_source(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r)
  921. {
  922.    while (n--) {
  923.       *r = ::mars_boost::move(*f);
  924.       ++f; ++r;
  925.    }
  926.    return f;
  927. }
  928.  
  929. template
  930. <typename I    // I models InputIterator
  931. ,typename F>   // F models ForwardIterator
  932. inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
  933.    move_n_source(I f, typename mars_boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
  934. {  return container_detail::memmove_n_source(f, n, r); }
  935.  
  936. //////////////////////////////////////////////////////////////////////////////
  937. //
  938. //                               destroy_alloc_n
  939. //
  940. //////////////////////////////////////////////////////////////////////////////
  941.  
  942. template
  943.    <typename Allocator
  944.    ,typename I   // I models InputIterator
  945.    ,typename U>  // U models unsigned integral constant
  946. inline typename container_detail::disable_if_trivially_destructible<I, void>::type
  947.    destroy_alloc_n(Allocator &a, I f, U n)
  948. {
  949.    while(n--){
  950.       allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(f));
  951.       ++f;
  952.    }
  953. }
  954.  
  955. template
  956.    <typename Allocator
  957.    ,typename I   // I models InputIterator
  958.    ,typename U>  // U models unsigned integral constant
  959. inline typename container_detail::enable_if_trivially_destructible<I, void>::type
  960.    destroy_alloc_n(Allocator &, I, U)
  961. {}
  962.  
  963. //////////////////////////////////////////////////////////////////////////////
  964. //
  965. //                         deep_swap_alloc_n
  966. //
  967. //////////////////////////////////////////////////////////////////////////////
  968.  
  969. template
  970.    <std::size_t MaxTmpBytes
  971.    ,typename Allocator
  972.    ,typename F // F models ForwardIterator
  973.    ,typename G // G models ForwardIterator
  974.    >
  975. inline typename container_detail::disable_if_memtransfer_copy_assignable<F, G, void>::type
  976.    deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
  977.                     , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
  978. {
  979.    typename allocator_traits<Allocator>::size_type n = 0;
  980.    for (; n != n_i ; ++short_range_f, ++large_range_f, ++n){
  981.       mars_boost::adl_move_swap(*short_range_f, *large_range_f);
  982.    }
  983.    mars_boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);  // may throw
  984.    mars_boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
  985. }
  986.  
  987. static const std::size_t DeepSwapAllocNMaxStorage = std::size_t(1) << std::size_t(11); //2K bytes
  988.  
  989. template
  990.    <std::size_t MaxTmpBytes
  991.    ,typename Allocator
  992.    ,typename F // F models ForwardIterator
  993.    ,typename G // G models ForwardIterator
  994.    >
  995. inline typename container_detail::enable_if_c
  996.    < container_detail::is_memtransfer_copy_assignable<F, G>::value && (MaxTmpBytes <= DeepSwapAllocNMaxStorage) && false
  997.    , void>::type
  998.    deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
  999.                     , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
  1000. {
  1001.    typedef typename allocator_traits<Allocator>::value_type value_type;
  1002.    typedef typename container_detail::aligned_storage
  1003.       <MaxTmpBytes, container_detail::alignment_of<value_type>::value>::type storage_type;
  1004.    storage_type storage;
  1005.  
  1006.    const std::size_t n_i_bytes = sizeof(value_type)*n_i;
  1007.    void *const large_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(large_range_f));
  1008.    void *const short_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(short_range_f));
  1009.    void *const stora_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(storage));
  1010.    std::memcpy(stora_ptr, large_ptr, n_i_bytes);
  1011.    std::memcpy(large_ptr, short_ptr, n_i_bytes);
  1012.    std::memcpy(short_ptr, stora_ptr, n_i_bytes);
  1013.    mars_boost::container::iterator_advance(large_range_f, n_i);
  1014.    mars_boost::container::iterator_advance(short_range_f, n_i);
  1015.    mars_boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);  // may throw
  1016.    mars_boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
  1017. }
  1018.  
  1019. template
  1020.    <std::size_t MaxTmpBytes
  1021.    ,typename Allocator
  1022.    ,typename F // F models ForwardIterator
  1023.    ,typename G // G models ForwardIterator
  1024.    >
  1025. inline typename container_detail::enable_if_c
  1026.    < container_detail::is_memtransfer_copy_assignable<F, G>::value && true//(MaxTmpBytes > DeepSwapAllocNMaxStorage)
  1027.    , void>::type
  1028.    deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
  1029.                     , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
  1030. {
  1031.    typedef typename allocator_traits<Allocator>::value_type value_type;
  1032.    typedef typename container_detail::aligned_storage
  1033.       <DeepSwapAllocNMaxStorage, container_detail::alignment_of<value_type>::value>::type storage_type;
  1034.    storage_type storage;
  1035.    const std::size_t sizeof_storage = sizeof(storage);
  1036.  
  1037.    std::size_t n_i_bytes = sizeof(value_type)*n_i;
  1038.    char *large_ptr = static_cast<char*>(static_cast<void*>(container_detail::iterator_to_raw_pointer(large_range_f)));
  1039.    char *short_ptr = static_cast<char*>(static_cast<void*>(container_detail::iterator_to_raw_pointer(short_range_f)));
  1040.    char *stora_ptr = static_cast<char*>(static_cast<void*>(&storage));
  1041.  
  1042.    std::size_t szt_times = n_i_bytes/sizeof_storage;
  1043.    const std::size_t szt_rem = n_i_bytes%sizeof_storage;
  1044.  
  1045.    //Loop unrolling using Duff's device, as it seems it helps on some architectures
  1046.    const std::size_t Unroll = 4;
  1047.    std::size_t n = (szt_times + (Unroll-1))/Unroll;
  1048.    const std::size_t branch_number = (!szt_times)*Unroll + (szt_times % Unroll);
  1049.    switch(branch_number){
  1050.       case 4:
  1051.          break;
  1052.       case 0: do{
  1053.          std::memcpy(stora_ptr, large_ptr, sizeof_storage);
  1054.          std::memcpy(large_ptr, short_ptr, sizeof_storage);
  1055.          std::memcpy(short_ptr, stora_ptr, sizeof_storage);
  1056.          large_ptr += sizeof_storage;
  1057.          short_ptr += sizeof_storage;
  1058.          BOOST_CONTAINER_FALLTHOUGH
  1059.       case 3:
  1060.          std::memcpy(stora_ptr, large_ptr, sizeof_storage);
  1061.          std::memcpy(large_ptr, short_ptr, sizeof_storage);
  1062.          std::memcpy(short_ptr, stora_ptr, sizeof_storage);
  1063.          large_ptr += sizeof_storage;
  1064.          short_ptr += sizeof_storage;
  1065.          BOOST_CONTAINER_FALLTHOUGH
  1066.       case 2:
  1067.          std::memcpy(stora_ptr, large_ptr, sizeof_storage);
  1068.          std::memcpy(large_ptr, short_ptr, sizeof_storage);
  1069.          std::memcpy(short_ptr, stora_ptr, sizeof_storage);
  1070.          large_ptr += sizeof_storage;
  1071.          short_ptr += sizeof_storage;
  1072.          BOOST_CONTAINER_FALLTHOUGH
  1073.       case 1:
  1074.          std::memcpy(stora_ptr, large_ptr, sizeof_storage);
  1075.          std::memcpy(large_ptr, short_ptr, sizeof_storage);
  1076.          std::memcpy(short_ptr, stora_ptr, sizeof_storage);
  1077.          large_ptr += sizeof_storage;
  1078.          short_ptr += sizeof_storage;
  1079.          } while(--n);
  1080.    }
  1081.    std::memcpy(stora_ptr, large_ptr, szt_rem);
  1082.    std::memcpy(large_ptr, short_ptr, szt_rem);
  1083.    std::memcpy(short_ptr, stora_ptr, szt_rem);
  1084.    mars_boost::container::iterator_advance(large_range_f, n_i);
  1085.    mars_boost::container::iterator_advance(short_range_f, n_i);
  1086.    mars_boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);  // may throw
  1087.    mars_boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
  1088. }
  1089.  
  1090.  
  1091. //////////////////////////////////////////////////////////////////////////////
  1092. //
  1093. //                         copy_assign_range_alloc_n
  1094. //
  1095. //////////////////////////////////////////////////////////////////////////////
  1096.  
  1097. template
  1098.    <typename Allocator
  1099.    ,typename I // F models InputIterator
  1100.    ,typename O // G models OutputIterator
  1101.    >
  1102. void copy_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits<Allocator>::size_type n_i
  1103.                               , O out_start, typename allocator_traits<Allocator>::size_type n_o )
  1104. {
  1105.    if (n_o < n_i){
  1106.       inp_start = mars_boost::container::copy_n_source_dest(inp_start, n_o, out_start);     // may throw
  1107.       mars_boost::container::uninitialized_copy_alloc_n(a, inp_start, n_i - n_o, out_start);// may throw
  1108.    }
  1109.    else{
  1110.       out_start = mars_boost::container::copy_n(inp_start, n_i, out_start);  // may throw
  1111.       mars_boost::container::destroy_alloc_n(a, out_start, n_o - n_i);
  1112.    }
  1113. }
  1114.  
  1115. //////////////////////////////////////////////////////////////////////////////
  1116. //
  1117. //                         move_assign_range_alloc_n
  1118. //
  1119. //////////////////////////////////////////////////////////////////////////////
  1120.  
  1121. template
  1122.    <typename Allocator
  1123.    ,typename I // F models InputIterator
  1124.    ,typename O // G models OutputIterator
  1125.    >
  1126. void move_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits<Allocator>::size_type n_i
  1127.                               , O out_start, typename allocator_traits<Allocator>::size_type n_o )
  1128. {
  1129.    if (n_o < n_i){
  1130.       inp_start = mars_boost::container::move_n_source_dest(inp_start, n_o, out_start);  // may throw
  1131.       mars_boost::container::uninitialized_move_alloc_n(a, inp_start, n_i - n_o, out_start);  // may throw
  1132.    }
  1133.    else{
  1134.       out_start = mars_boost::container::move_n(inp_start, n_i, out_start);  // may throw
  1135.       mars_boost::container::destroy_alloc_n(a, out_start, n_o - n_i);
  1136.    }
  1137. }
  1138.  
  1139. }  //namespace container {
  1140. }  //namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  1141.  
  1142. #endif   //#ifndef BOOST_CONTAINER_DETAIL_UTILITIES_HPP
  1143.  
downloadcopy_move_algo.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