BVB Source Codes

mars Show pointer_traits.hpp Source code

Return Download mars: download pointer_traits.hpp Source code - Download mars Source code - Type:.hpp
  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. // (C) Copyright Pablo Halpern 2009. 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. //////////////////////////////////////////////////////////////////////////////
  8. //
  9. // (C) Copyright Ion Gaztanaga 2011-2014. Distributed under the Boost
  10. // Software License, Version 1.0. (See accompanying file
  11. // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  12. //
  13. // See http://www.boost.org/libs/intrusive for documentation.
  14. //
  15. //////////////////////////////////////////////////////////////////////////////
  16.  
  17. #ifndef BOOST_INTRUSIVE_POINTER_TRAITS_HPP
  18. #define BOOST_INTRUSIVE_POINTER_TRAITS_HPP
  19.  
  20. #include <boost/intrusive/detail/config_begin.hpp>
  21. #include <boost/intrusive/detail/workaround.hpp>
  22. #include <boost/intrusive/pointer_rebind.hpp>
  23. #include <boost/intrusive/detail/pointer_element.hpp>
  24. #include <boost/intrusive/detail/mpl.hpp>
  25. #include <cstddef>
  26.  
  27. #if defined(BOOST_HAS_PRAGMA_ONCE)
  28. #  pragma once
  29. #endif
  30.  
  31. namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  32. namespace intrusive {
  33. namespace detail {
  34.  
  35. #if !defined(BOOST_MSVC) || (BOOST_MSVC > 1310)
  36. BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_pointer_to, pointer_to)
  37. BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_dynamic_cast_from, dynamic_cast_from)
  38. BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_static_cast_from, static_cast_from)
  39. BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_member_function_callable_with_const_cast_from, const_cast_from)
  40. #else
  41. BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_pointer_to, pointer_to)
  42. BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_dynamic_cast_from, dynamic_cast_from)
  43. BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_static_cast_from, static_cast_from)
  44. BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_callable_with_const_cast_from, const_cast_from)
  45. #endif
  46.  
  47. BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(element_type)
  48. BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
  49. BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
  50. BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr)
  51.  
  52. }  //namespace detail {
  53.  
  54.  
  55. //! pointer_traits is the implementation of C++11 std::pointer_traits class with some
  56. //! extensions like castings.
  57. //!
  58. //! pointer_traits supplies a uniform interface to certain attributes of pointer-like types.
  59. //!
  60. //! <b>Note</b>: When defining a custom family of pointers or references to be used with BI
  61. //! library, make sure the public static conversion functions accessed through
  62. //! the `pointer_traits` interface (`*_cast_from` and `pointer_to`) can
  63. //! properly convert between const and nonconst referred member types
  64. //! <b>without the use of implicit constructor calls</b>. It is suggested these
  65. //! conversions be implemented as function templates, where the template
  66. //! argument is the type of the object being converted from.
  67. template <typename Ptr>
  68. struct pointer_traits
  69. {
  70.    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
  71.       //!The pointer type
  72.       //!queried by this pointer_traits instantiation
  73.       typedef Ptr             pointer;
  74.  
  75.       //!Ptr::element_type if such a type exists; otherwise, T if Ptr is a class
  76.       //!template instantiation of the form SomePointer<T, Args>, where Args is zero or
  77.       //!more type arguments ; otherwise , the specialization is ill-formed.
  78.       typedef unspecified_type element_type;
  79.  
  80.       //!Ptr::difference_type if such a type exists; otherwise,
  81.       //!std::ptrdiff_t.
  82.       typedef unspecified_type difference_type;
  83.  
  84.       //!Ptr::rebind<U> if such a type exists; otherwise, SomePointer<U, Args> if Ptr is
  85.       //!a class template instantiation of the form SomePointer<T, Args>, where Args is zero or
  86.       //!more type arguments ; otherwise, the instantiation of rebind is ill-formed.
  87.       //!
  88.       //!For portable code for C++03 and C++11, <pre>typename rebind_pointer<U>::type</pre>
  89.       //!shall be used instead of rebind<U> to obtain a pointer to U.
  90.       template <class U> using rebind = unspecified;
  91.  
  92.       //!Ptr::reference if such a type exists (non-standard extension); otherwise, element_type &
  93.       //!
  94.       typedef unspecified_type reference;
  95.    #else
  96.       typedef Ptr                                                             pointer;
  97.       //
  98.       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT
  99.          ( mars_boost::intrusive::detail::, Ptr, element_type
  100.          , mars_boost::intrusive::detail::first_param<Ptr>)                        element_type;
  101.       //
  102.       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
  103.          (mars_boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t)   difference_type;
  104.  
  105.       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
  106.          (mars_boost::intrusive::detail::, Ptr, reference, typename mars_boost::intrusive::detail::unvoid_ref<element_type>::type)   reference;
  107.       //
  108.       template <class U> struct rebind_pointer
  109.       {
  110.          typedef typename mars_boost::intrusive::pointer_rebind<Ptr, U>::type  type;
  111.       };
  112.  
  113.       #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
  114.          template <class U> using rebind = typename mars_boost::intrusive::pointer_rebind<Ptr, U>::type;
  115.       #endif
  116.    #endif   //#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
  117.  
  118.    //! <b>Remark</b>: If element_type is (possibly cv-qualified) void, r type is unspecified; otherwise,
  119.    //!   it is element_type &.
  120.    //!
  121.    //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling Ptr::pointer_to(reference).
  122.    //!   Non-standard extension: If such function does not exist, returns pointer(addressof(r));
  123.    //!
  124.    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
  125.    //!   <code>pointer_to</code> is checked.
  126.    static pointer pointer_to(reference r)
  127.    {
  128.       //Non-standard extension, it does not require Ptr::pointer_to. If not present
  129.       //tries to converts &r to pointer.
  130.       const bool value = mars_boost::intrusive::detail::
  131.          has_member_function_callable_with_pointer_to
  132.             <Ptr, Ptr (*)(reference)>::value;
  133.       mars_boost::intrusive::detail::bool_<value> flag;
  134.       return pointer_traits::priv_pointer_to(flag, r);
  135.    }
  136.  
  137.    //! <b>Remark</b>: Non-standard extension.
  138.    //!
  139.    //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
  140.    //!   Ptr::static_cast_from(UPpr/const UPpr &).
  141.    //!   If such function does not exist, returns pointer_to(static_cast<element_type&>(*uptr))
  142.    //!
  143.    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
  144.    //!   <code>static_cast_from</code> is checked.
  145.    template<class UPtr>
  146.    static pointer static_cast_from(const UPtr &uptr)
  147.    {
  148.       typedef const UPtr &RefArg;
  149.       const bool value = mars_boost::intrusive::detail::
  150.          has_member_function_callable_with_static_cast_from
  151.             <pointer, pointer(*)(RefArg)>::value
  152.          || mars_boost::intrusive::detail::
  153.                has_member_function_callable_with_static_cast_from
  154.                   <pointer, pointer(*)(UPtr)>::value;
  155.       return pointer_traits::priv_static_cast_from(mars_boost::intrusive::detail::bool_<value>(), uptr);
  156.    }
  157.  
  158.    //! <b>Remark</b>: Non-standard extension.
  159.    //!
  160.    //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
  161.    //!   Ptr::const_cast_from<UPtr>(UPpr/const UPpr &).
  162.    //!   If such function does not exist, returns pointer_to(const_cast<element_type&>(*uptr))
  163.    //!
  164.    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
  165.    //!   <code>const_cast_from</code> is checked.
  166.    template<class UPtr>
  167.    static pointer const_cast_from(const UPtr &uptr)
  168.    {
  169.       typedef const UPtr &RefArg;
  170.       const bool value = mars_boost::intrusive::detail::
  171.          has_member_function_callable_with_const_cast_from
  172.             <pointer, pointer(*)(RefArg)>::value
  173.          || mars_boost::intrusive::detail::
  174.                has_member_function_callable_with_const_cast_from
  175.                   <pointer, pointer(*)(UPtr)>::value;
  176.       return pointer_traits::priv_const_cast_from(mars_boost::intrusive::detail::bool_<value>(), uptr);
  177.    }
  178.  
  179.    //! <b>Remark</b>: Non-standard extension.
  180.    //!
  181.    //! <b>Returns</b>: A dereferenceable pointer to r obtained by calling the static template function
  182.    //!   Ptr::dynamic_cast_from<UPtr>(UPpr/const UPpr &).
  183.    //!   If such function does not exist, returns pointer_to(*dynamic_cast<element_type*>(&*uptr))
  184.    //!
  185.    //! <b>Note</b>: For non-conforming compilers only the existence of a member function called
  186.    //!   <code>dynamic_cast_from</code> is checked.
  187.    template<class UPtr>
  188.    static pointer dynamic_cast_from(const UPtr &uptr)
  189.    {
  190.       typedef const UPtr &RefArg;
  191.       const bool value = mars_boost::intrusive::detail::
  192.          has_member_function_callable_with_dynamic_cast_from
  193.             <pointer, pointer(*)(RefArg)>::value
  194.          || mars_boost::intrusive::detail::
  195.                has_member_function_callable_with_dynamic_cast_from
  196.                   <pointer, pointer(*)(UPtr)>::value;
  197.       return pointer_traits::priv_dynamic_cast_from(mars_boost::intrusive::detail::bool_<value>(), uptr);
  198.    }
  199.  
  200.    ///@cond
  201.    private:
  202.    //priv_to_raw_pointer
  203.    template <class T>
  204.    static T* to_raw_pointer(T* p)
  205.    {  return p; }
  206.  
  207.    template <class Pointer>
  208.    static typename pointer_traits<Pointer>::element_type*
  209.       to_raw_pointer(const Pointer &p)
  210.    {  return pointer_traits::to_raw_pointer(p.operator->());  }
  211.  
  212.    //priv_pointer_to
  213.    static pointer priv_pointer_to(mars_boost::intrusive::detail::true_, reference r)
  214.    { return Ptr::pointer_to(r); }
  215.  
  216.    static pointer priv_pointer_to(mars_boost::intrusive::detail::false_, reference r)
  217.    { return pointer(mars_boost::intrusive::detail::addressof(r)); }
  218.  
  219.    //priv_static_cast_from
  220.    template<class UPtr>
  221.    static pointer priv_static_cast_from(mars_boost::intrusive::detail::true_, const UPtr &uptr)
  222.    { return Ptr::static_cast_from(uptr); }
  223.  
  224.    template<class UPtr>
  225.    static pointer priv_static_cast_from(mars_boost::intrusive::detail::false_, const UPtr &uptr)
  226.    {  return uptr ? pointer_to(*static_cast<element_type*>(to_raw_pointer(uptr))) : pointer();  }
  227.  
  228.    //priv_const_cast_from
  229.    template<class UPtr>
  230.    static pointer priv_const_cast_from(mars_boost::intrusive::detail::true_, const UPtr &uptr)
  231.    { return Ptr::const_cast_from(uptr); }
  232.  
  233.    template<class UPtr>
  234.    static pointer priv_const_cast_from(mars_boost::intrusive::detail::false_, const UPtr &uptr)
  235.    {  return uptr ? pointer_to(const_cast<element_type&>(*uptr)) : pointer();  }
  236.  
  237.    //priv_dynamic_cast_from
  238.    template<class UPtr>
  239.    static pointer priv_dynamic_cast_from(mars_boost::intrusive::detail::true_, const UPtr &uptr)
  240.    { return Ptr::dynamic_cast_from(uptr); }
  241.  
  242.    template<class UPtr>
  243.    static pointer priv_dynamic_cast_from(mars_boost::intrusive::detail::false_, const UPtr &uptr)
  244.    {  return uptr ? pointer_to(dynamic_cast<element_type&>(*uptr)) : pointer();  }
  245.    ///@endcond
  246. };
  247.  
  248. ///@cond
  249.  
  250. // Remove cv qualification from Ptr parameter to pointer_traits:
  251. template <typename Ptr>
  252. struct pointer_traits<const Ptr> : pointer_traits<Ptr> {};
  253. template <typename Ptr>
  254. struct pointer_traits<volatile Ptr> : pointer_traits<Ptr> { };
  255. template <typename Ptr>
  256. struct pointer_traits<const volatile Ptr> : pointer_traits<Ptr> { };
  257. // Remove reference from Ptr parameter to pointer_traits:
  258. template <typename Ptr>
  259. struct pointer_traits<Ptr&> : pointer_traits<Ptr> { };
  260.  
  261. ///@endcond
  262.  
  263. //! Specialization of pointer_traits for raw pointers
  264. //!
  265. template <typename T>
  266. struct pointer_traits<T*>
  267. {
  268.    typedef T            element_type;
  269.    typedef T*           pointer;
  270.    typedef std::ptrdiff_t difference_type;
  271.  
  272.    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
  273.       typedef T &          reference;
  274.       //!typedef for <pre>U *</pre>
  275.       //!
  276.       //!For portable code for C++03 and C++11, <pre>typename rebind_pointer<U>::type</pre>
  277.       //!shall be used instead of rebind<U> to obtain a pointer to U.
  278.       template <class U> using rebind = U*;
  279.    #else
  280.       typedef typename mars_boost::intrusive::detail::unvoid_ref<element_type>::type reference;
  281.       #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
  282.          template <class U> using rebind = U*;
  283.       #endif
  284.    #endif
  285.  
  286.    template <class U> struct rebind_pointer
  287.    {  typedef U* type;  };
  288.  
  289.    //! <b>Returns</b>: addressof(r)
  290.    //!
  291.    static pointer pointer_to(reference r)
  292.    { return mars_boost::intrusive::detail::addressof(r); }
  293.  
  294.    //! <b>Returns</b>: static_cast<pointer>(uptr)
  295.    //!
  296.    template<class U>
  297.    static pointer static_cast_from(U *uptr)
  298.    {  return static_cast<pointer>(uptr);  }
  299.  
  300.    //! <b>Returns</b>: const_cast<pointer>(uptr)
  301.    //!
  302.    template<class U>
  303.    static pointer const_cast_from(U *uptr)
  304.    {  return const_cast<pointer>(uptr);  }
  305.  
  306.    //! <b>Returns</b>: dynamic_cast<pointer>(uptr)
  307.    //!
  308.    template<class U>
  309.    static pointer dynamic_cast_from(U *uptr)
  310.    {  return dynamic_cast<pointer>(uptr);  }
  311. };
  312.  
  313. }  //namespace container {
  314. }  //namespace mars_boost {} namespace boost = mars_boost; namespace mars_boost {
  315.  
  316. #include <boost/intrusive/detail/config_end.hpp>
  317.  
  318. #endif // ! defined(BOOST_INTRUSIVE_POINTER_TRAITS_HPP)
  319.  
downloadpointer_traits.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