BVB Source Codes

mars Show advanced_insert_int.hpp Source code

Return Download mars: download advanced_insert_int.hpp Source code - Download mars Source code - Type:.hpp
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. // (C) Copyright Ion Gaztanaga 2008-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.  
  11. #ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
  12. #define BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
  13.  
  14. #ifndef BOOST_CONFIG_HPP
  15. #  include <boost/config.hpp>
  16. #endif
  17.  
  18. #if defined(BOOST_HAS_PRAGMA_ONCE)
  19. #  pragma once
  20. #endif
  21.  
  22. #include <boost/container/detail/config_begin.hpp>
  23. #include <boost/container/detail/workaround.hpp>
  24.  
  25. // container
  26. #include <boost/container/allocator_traits.hpp>
  27. // container/detail
  28. #include <boost/container/detail/copy_move_algo.hpp>
  29. #include <boost/container/detail/destroyers.hpp>
  30. #include <boost/container/detail/mpl.hpp>
  31. #include <boost/container/detail/type_traits.hpp>
  32. #include <boost/container/detail/iterator.hpp>
  33. #include <boost/container/detail/iterators.hpp>
  34. #include <boost/container/detail/iterator_to_raw_pointer.hpp>
  35. #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
  36. #include <boost/move/detail/fwd_macros.hpp>
  37. #endif
  38. // move
  39. #include <boost/move/utility_core.hpp>
  40. // other
  41. #include <boost/assert.hpp>
  42. #include <boost/core/no_exceptions_support.hpp>
  43.  
  44. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost { namespace container { namespace container_detail {
  45.  
  46. template<class Allocator, class FwdIt, class Iterator>
  47. struct move_insert_range_proxy
  48. {
  49.    typedef typename allocator_traits<Allocator>::size_type size_type;
  50.    typedef typename allocator_traits<Allocator>::value_type value_type;
  51.  
  52.    explicit move_insert_range_proxy(FwdIt first)
  53.       :  first_(first)
  54.    {}
  55.  
  56.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
  57.    {
  58.       this->first_ = ::mars_boost::container::uninitialized_move_alloc_n_source
  59.          (a, this->first_, n, p);
  60.    }
  61.  
  62.    void copy_n_and_update(Allocator &, Iterator p, size_type n)
  63.    {
  64.       this->first_ = ::mars_boost::container::move_n_source(this->first_, n, p);
  65.    }
  66.  
  67.    FwdIt first_;
  68. };
  69.  
  70.  
  71. template<class Allocator, class FwdIt, class Iterator>
  72. struct insert_range_proxy
  73. {
  74.    typedef typename allocator_traits<Allocator>::size_type size_type;
  75.    typedef typename allocator_traits<Allocator>::value_type value_type;
  76.  
  77.    explicit insert_range_proxy(FwdIt first)
  78.       :  first_(first)
  79.    {}
  80.  
  81.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
  82.    {
  83.       this->first_ = ::mars_boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
  84.    }
  85.  
  86.    void copy_n_and_update(Allocator &, Iterator p, size_type n)
  87.    {
  88.       this->first_ = ::mars_boost::container::copy_n_source(this->first_, n, p);
  89.    }
  90.  
  91.    FwdIt first_;
  92. };
  93.  
  94.  
  95. template<class Allocator, class Iterator>
  96. struct insert_n_copies_proxy
  97. {
  98.    typedef typename allocator_traits<Allocator>::size_type size_type;
  99.    typedef typename allocator_traits<Allocator>::value_type value_type;
  100.  
  101.    explicit insert_n_copies_proxy(const value_type &v)
  102.       :  v_(v)
  103.    {}
  104.  
  105.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
  106.    {  mars_boost::container::uninitialized_fill_alloc_n(a, v_, n, p);  }
  107.  
  108.    void copy_n_and_update(Allocator &, Iterator p, size_type n) const
  109.    {
  110.            for (; 0 < n; --n, ++p){
  111.                    *p = v_;
  112.       }
  113.    }
  114.  
  115.    const value_type &v_;
  116. };
  117.  
  118. template<class Allocator, class Iterator>
  119. struct insert_value_initialized_n_proxy
  120. {
  121.    typedef ::mars_boost::container::allocator_traits<Allocator> alloc_traits;
  122.    typedef typename allocator_traits<Allocator>::size_type size_type;
  123.    typedef typename allocator_traits<Allocator>::value_type value_type;
  124.  
  125.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
  126.    {  mars_boost::container::uninitialized_value_init_alloc_n(a, n, p);  }
  127.  
  128.    void copy_n_and_update(Allocator &, Iterator, size_type) const
  129.    {  BOOST_ASSERT(false); }
  130. };
  131.  
  132. template<class Allocator, class Iterator>
  133. struct insert_default_initialized_n_proxy
  134. {
  135.    typedef ::mars_boost::container::allocator_traits<Allocator> alloc_traits;
  136.    typedef typename allocator_traits<Allocator>::size_type size_type;
  137.    typedef typename allocator_traits<Allocator>::value_type value_type;
  138.  
  139.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
  140.    {  mars_boost::container::uninitialized_default_init_alloc_n(a, n, p);  }
  141.  
  142.    void copy_n_and_update(Allocator &, Iterator, size_type) const
  143.    {  BOOST_ASSERT(false); }
  144. };
  145.  
  146. template<class Allocator, class Iterator>
  147. struct insert_copy_proxy
  148. {
  149.    typedef mars_boost::container::allocator_traits<Allocator> alloc_traits;
  150.    typedef typename alloc_traits::size_type size_type;
  151.    typedef typename alloc_traits::value_type value_type;
  152.  
  153.    explicit insert_copy_proxy(const value_type &v)
  154.       :  v_(v)
  155.    {}
  156.  
  157.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
  158.    {
  159.       BOOST_ASSERT(n == 1);  (void)n;
  160.       alloc_traits::construct( a, iterator_to_raw_pointer(p), v_);
  161.    }
  162.  
  163.    void copy_n_and_update(Allocator &, Iterator p, size_type n) const
  164.    {
  165.       BOOST_ASSERT(n == 1);  (void)n;
  166.       *p =v_;
  167.    }
  168.  
  169.    const value_type &v_;
  170. };
  171.  
  172.  
  173. template<class Allocator, class Iterator>
  174. struct insert_move_proxy
  175. {
  176.    typedef mars_boost::container::allocator_traits<Allocator> alloc_traits;
  177.    typedef typename alloc_traits::size_type size_type;
  178.    typedef typename alloc_traits::value_type value_type;
  179.  
  180.    explicit insert_move_proxy(value_type &v)
  181.       :  v_(v)
  182.    {}
  183.  
  184.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
  185.    {
  186.       BOOST_ASSERT(n == 1);  (void)n;
  187.       alloc_traits::construct( a, iterator_to_raw_pointer(p), ::mars_boost::move(v_) );
  188.    }
  189.  
  190.    void copy_n_and_update(Allocator &, Iterator p, size_type n) const
  191.    {
  192.       BOOST_ASSERT(n == 1);  (void)n;
  193.       *p = ::mars_boost::move(v_);
  194.    }
  195.  
  196.    value_type &v_;
  197. };
  198.  
  199. template<class It, class Allocator>
  200. insert_move_proxy<Allocator, It> get_insert_value_proxy(BOOST_RV_REF(typename mars_boost::container::iterator_traits<It>::value_type) v)
  201. {
  202.    return insert_move_proxy<Allocator, It>(v);
  203. }
  204.  
  205. template<class It, class Allocator>
  206. insert_copy_proxy<Allocator, It> get_insert_value_proxy(const typename mars_boost::container::iterator_traits<It>::value_type &v)
  207. {
  208.    return insert_copy_proxy<Allocator, It>(v);
  209. }
  210.  
  211. }}}   //namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost { namespace container { namespace container_detail {
  212.  
  213. #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
  214.  
  215. #include <boost/container/detail/variadic_templates_tools.hpp>
  216. #include <boost/move/utility_core.hpp>
  217.  
  218. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  219. namespace container {
  220. namespace container_detail {
  221.  
  222. template<class Allocator, class Iterator, class ...Args>
  223. struct insert_nonmovable_emplace_proxy
  224. {
  225.    typedef mars_boost::container::allocator_traits<Allocator>   alloc_traits;
  226.    typedef typename alloc_traits::size_type        size_type;
  227.    typedef typename alloc_traits::value_type       value_type;
  228.  
  229.    typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;
  230.  
  231.    explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args)
  232.       : args_(args...)
  233.    {}
  234.  
  235.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
  236.    {  this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n);  }
  237.  
  238.    private:
  239.    template<int ...IdxPack>
  240.    void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
  241.    {
  242.       BOOST_ASSERT(n == 1); (void)n;
  243.       alloc_traits::construct( a, iterator_to_raw_pointer(p), ::mars_boost::forward<Args>(get<IdxPack>(this->args_))... );
  244.    }
  245.  
  246.    protected:
  247.    tuple<Args&...> args_;
  248. };
  249.  
  250. template<class Allocator, class Iterator, class ...Args>
  251. struct insert_emplace_proxy
  252.    :  public insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...>
  253. {
  254.    typedef insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...> base_t;
  255.    typedef mars_boost::container::allocator_traits<Allocator>   alloc_traits;
  256.    typedef typename base_t::value_type             value_type;
  257.    typedef typename base_t::size_type              size_type;
  258.    typedef typename base_t::index_tuple_t          index_tuple_t;
  259.  
  260.    explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args)
  261.       : base_t(::mars_boost::forward<Args>(args)...)
  262.    {}
  263.  
  264.    void copy_n_and_update(Allocator &a, Iterator p, size_type n)
  265.    {  this->priv_copy_some_and_update(a, index_tuple_t(), p, n);  }
  266.  
  267.    private:
  268.  
  269.    template<int ...IdxPack>
  270.    void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
  271.    {
  272.       BOOST_ASSERT(n ==1); (void)n;
  273.       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;
  274.       value_type *vp = static_cast<value_type *>(static_cast<void *>(&v));
  275.       alloc_traits::construct(a, vp,
  276.          ::mars_boost::forward<Args>(get<IdxPack>(this->args_))...);
  277.       BOOST_TRY{
  278.          *p = ::mars_boost::move(*vp);
  279.       }
  280.       BOOST_CATCH(...){
  281.          alloc_traits::destroy(a, vp);
  282.          BOOST_RETHROW
  283.       }
  284.       BOOST_CATCH_END
  285.       alloc_traits::destroy(a, vp);
  286.    }
  287. };
  288.  
  289. //Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type
  290. template<class Allocator, class Iterator>
  291. struct insert_emplace_proxy<Allocator, Iterator, typename mars_boost::container::allocator_traits<Allocator>::value_type>
  292.    : public insert_move_proxy<Allocator, Iterator>
  293. {
  294.    explicit insert_emplace_proxy(typename mars_boost::container::allocator_traits<Allocator>::value_type &&v)
  295.    : insert_move_proxy<Allocator, Iterator>(v)
  296.    {}
  297. };
  298.  
  299. //We use "add_const" here as adding "const" only confuses MSVC12(and maybe later) provoking
  300. //compiler error C2752 ("more than one partial specialization matches").
  301. //Any problem is solvable with an extra layer of indirection? ;-)
  302. template<class Allocator, class Iterator>
  303. struct insert_emplace_proxy<Allocator, Iterator
  304.    , typename mars_boost::container::container_detail::add_const<typename mars_boost::container::allocator_traits<Allocator>::value_type>::type
  305.    >
  306.    : public insert_copy_proxy<Allocator, Iterator>
  307. {
  308.    explicit insert_emplace_proxy(const typename mars_boost::container::allocator_traits<Allocator>::value_type &v)
  309.    : insert_copy_proxy<Allocator, Iterator>(v)
  310.    {}
  311. };
  312.  
  313. template<class Allocator, class Iterator>
  314. struct insert_emplace_proxy<Allocator, Iterator, typename mars_boost::container::allocator_traits<Allocator>::value_type &>
  315.    : public insert_copy_proxy<Allocator, Iterator>
  316. {
  317.    explicit insert_emplace_proxy(const typename mars_boost::container::allocator_traits<Allocator>::value_type &v)
  318.    : insert_copy_proxy<Allocator, Iterator>(v)
  319.    {}
  320. };
  321.  
  322. template<class Allocator, class Iterator>
  323. struct insert_emplace_proxy<Allocator, Iterator
  324.    , typename mars_boost::container::container_detail::add_const<typename mars_boost::container::allocator_traits<Allocator>::value_type>::type &
  325.    >
  326.    : public insert_copy_proxy<Allocator, Iterator>
  327. {
  328.    explicit insert_emplace_proxy(const typename mars_boost::container::allocator_traits<Allocator>::value_type &v)
  329.    : insert_copy_proxy<Allocator, Iterator>(v)
  330.    {}
  331. };
  332.  
  333. }}}   //namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost { namespace container { namespace container_detail {
  334.  
  335. #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
  336.  
  337. #include <boost/container/detail/value_init.hpp>
  338.  
  339. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  340. namespace container {
  341. namespace container_detail {
  342.  
  343. #define BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE(N) \
  344. template< class Allocator, class Iterator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
  345. struct insert_nonmovable_emplace_proxy##N\
  346. {\
  347.    typedef mars_boost::container::allocator_traits<Allocator> alloc_traits;\
  348.    typedef typename alloc_traits::size_type size_type;\
  349.    typedef typename alloc_traits::value_type value_type;\
  350.    \
  351.    explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
  352.       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\
  353.    \
  354.    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)\
  355.    {\
  356.       BOOST_ASSERT(n == 1); (void)n;\
  357.       alloc_traits::construct(a, iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
  358.    }\
  359.    \
  360.    void copy_n_and_update(Allocator &, Iterator, size_type)\
  361.    {  BOOST_ASSERT(false);   }\
  362.    \
  363.    protected:\
  364.    BOOST_MOVE_MREF##N\
  365. };\
  366. \
  367. template< class Allocator, class Iterator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
  368. struct insert_emplace_proxy_arg##N\
  369.    : insert_nonmovable_emplace_proxy##N< Allocator, Iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N >\
  370. {\
  371.    typedef insert_nonmovable_emplace_proxy##N\
  372.       < Allocator, Iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N > base_t;\
  373.    typedef typename base_t::value_type value_type;\
  374.    typedef typename base_t::size_type size_type;\
  375.    typedef mars_boost::container::allocator_traits<Allocator> alloc_traits;\
  376.    \
  377.    explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
  378.       : base_t(BOOST_MOVE_FWD##N){}\
  379.    \
  380.    void copy_n_and_update(Allocator &a, Iterator p, size_type n)\
  381.    {\
  382.       BOOST_ASSERT(n == 1); (void)n;\
  383.       typename aligned_storage<sizeof(value_type), alignment_of<value_type>::value>::type v;\
  384.       BOOST_ASSERT((((size_type)(&v)) % alignment_of<value_type>::value) == 0);\
  385.       value_type *vp = static_cast<value_type *>(static_cast<void *>(&v));\
  386.       alloc_traits::construct(a, vp BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
  387.       BOOST_TRY{\
  388.          *p = ::mars_boost::move(*vp);\
  389.       }\
  390.       BOOST_CATCH(...){\
  391.          alloc_traits::destroy(a, vp);\
  392.          BOOST_RETHROW\
  393.       }\
  394.       BOOST_CATCH_END\
  395.       alloc_traits::destroy(a, vp);\
  396.    }\
  397. };\
  398. //
  399. BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE)
  400. #undef BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE
  401.  
  402. #if defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  403.  
  404. //Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type
  405. template<class Allocator, class Iterator>
  406. struct insert_emplace_proxy_arg1<Allocator, Iterator, ::mars_boost::rv<typename mars_boost::container::allocator_traits<Allocator>::value_type> >
  407.    : public insert_move_proxy<Allocator, Iterator>
  408. {
  409.    explicit insert_emplace_proxy_arg1(typename mars_boost::container::allocator_traits<Allocator>::value_type &v)
  410.    : insert_move_proxy<Allocator, Iterator>(v)
  411.    {}
  412. };
  413.  
  414. template<class Allocator, class Iterator>
  415. struct insert_emplace_proxy_arg1<Allocator, Iterator, typename mars_boost::container::allocator_traits<Allocator>::value_type>
  416.    : public insert_copy_proxy<Allocator, Iterator>
  417. {
  418.    explicit insert_emplace_proxy_arg1(const typename mars_boost::container::allocator_traits<Allocator>::value_type &v)
  419.    : insert_copy_proxy<Allocator, Iterator>(v)
  420.    {}
  421. };
  422.  
  423. #else //e.g. MSVC10 & MSVC11
  424.  
  425. //Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type
  426. template<class Allocator, class Iterator>
  427. struct insert_emplace_proxy_arg1<Allocator, Iterator, typename mars_boost::container::allocator_traits<Allocator>::value_type>
  428.    : public insert_move_proxy<Allocator, Iterator>
  429. {
  430.    explicit insert_emplace_proxy_arg1(typename mars_boost::container::allocator_traits<Allocator>::value_type &&v)
  431.    : insert_move_proxy<Allocator, Iterator>(v)
  432.    {}
  433. };
  434.  
  435. //We use "add_const" here as adding "const" only confuses MSVC10&11 provoking
  436. //compiler error C2752 ("more than one partial specialization matches").
  437. //Any problem is solvable with an extra layer of indirection? ;-)
  438. template<class Allocator, class Iterator>
  439. struct insert_emplace_proxy_arg1<Allocator, Iterator
  440.    , typename mars_boost::container::container_detail::add_const<typename mars_boost::container::allocator_traits<Allocator>::value_type>::type
  441.    >
  442.    : public insert_copy_proxy<Allocator, Iterator>
  443. {
  444.    explicit insert_emplace_proxy_arg1(const typename mars_boost::container::allocator_traits<Allocator>::value_type &v)
  445.    : insert_copy_proxy<Allocator, Iterator>(v)
  446.    {}
  447. };
  448.  
  449. template<class Allocator, class Iterator>
  450. struct insert_emplace_proxy_arg1<Allocator, Iterator, typename mars_boost::container::allocator_traits<Allocator>::value_type &>
  451.    : public insert_copy_proxy<Allocator, Iterator>
  452. {
  453.    explicit insert_emplace_proxy_arg1(const typename mars_boost::container::allocator_traits<Allocator>::value_type &v)
  454.    : insert_copy_proxy<Allocator, Iterator>(v)
  455.    {}
  456. };
  457.  
  458. template<class Allocator, class Iterator>
  459. struct insert_emplace_proxy_arg1<Allocator, Iterator
  460.    , typename mars_boost::container::container_detail::add_const<typename mars_boost::container::allocator_traits<Allocator>::value_type>::type &
  461.    >
  462.    : public insert_copy_proxy<Allocator, Iterator>
  463. {
  464.    explicit insert_emplace_proxy_arg1(const typename mars_boost::container::allocator_traits<Allocator>::value_type &v)
  465.    : insert_copy_proxy<Allocator, Iterator>(v)
  466.    {}
  467. };
  468.  
  469. #endif
  470.  
  471. }}}   //namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost { namespace container { namespace container_detail {
  472.  
  473. #endif   // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
  474.  
  475. #include <boost/container/detail/config_end.hpp>
  476.  
  477. #endif //#ifndef BOOST_CONTAINER_ADVANCED_INSERT_INT_HPP
  478.  
downloadadvanced_insert_int.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