/Src/Dependencies/Boost/boost/random/detail/ptr_helper.hpp

http://hadesmem.googlecode.com/ · C++ Header · 94 lines · 65 code · 10 blank · 19 comment · 0 complexity · dfb06cb89100c723922f6751187be3ba MD5 · raw file 

    

  1. /* boost random/detail/ptr_helper.hpp header file
    2. 

  2.  *
    3. 

  3.  * Copyright Jens Maurer 2002
    4. 

  4.  * Distributed under the Boost Software License, Version 1.0. (See
    5. 

  5.  * accompanying file LICENSE_1_0.txt or copy at
    6. 

  6.  * http://www.boost.org/LICENSE_1_0.txt)
    7. 

  7.  *
    8. 

  8.  * See http://www.boost.org for most recent version including documentation.
    9. 

  9.  *
    10. 

  10.  * $Id: ptr_helper.hpp 24096 2004-07-27 03:43:34Z dgregor $
    11. 

  11.  *
    12. 

  12.  */
    13. 

  13. 

  14. #ifndef BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
    15. 

  15. #define BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
    16. 

  16. 

  17. #include <boost/config.hpp>
    18. 

  18. 

  19. 

  20. namespace boost {
    21. 

  21. namespace random {
    22. 

  22. namespace detail {
    23. 

  23. 

  24. // type_traits could help here, but I don't want to depend on type_traits.
    25. 

  25. template<class T>
    26. 

  26. struct ptr_helper
    27. 

  27. {
    28. 

  28.   typedef T value_type;
    29. 

  29.   typedef T& reference_type;
    30. 

  30.   typedef const T& rvalue_type;
    31. 

  31.   static reference_type ref(T& r) { return r; }
    32. 

  32.   static const T& ref(const T& r) { return r; }
    33. 

  33. };
    34. 

  34. 

  35. #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    36. 

  36. template<class T>
    37. 

  37. struct ptr_helper<T&>
    38. 

  38. {
    39. 

  39.   typedef T value_type;
    40. 

  40.   typedef T& reference_type;
    41. 

  41.   typedef T& rvalue_type;
    42. 

  42.   static reference_type ref(T& r) { return r; }
    43. 

  43.   static const T& ref(const T& r) { return r; }
    44. 

  44. };
    45. 

  45. 

  46. template<class T>
    47. 

  47. struct ptr_helper<T*>
    48. 

  48. {
    49. 

  49.   typedef T value_type;
    50. 

  50.   typedef T& reference_type;
    51. 

  51.   typedef T* rvalue_type;
    52. 

  52.   static reference_type ref(T * p) { return *p; }
    53. 

  53.   static const T& ref(const T * p) { return *p; }
    54. 

  54. };
    55. 

  55. #endif
    56. 

  56. 

  57. } // namespace detail
    58. 

  58. } // namespace random
    59. 

  59. } // namespace boost
    60. 

  60. 

  61. //
    62. 

  62. // BOOST_RANDOM_PTR_HELPER_SPEC --
    63. 

  63. //
    64. 

  64. //  Helper macro for broken compilers defines specializations of
    65. 

  65. //  ptr_helper.
    66. 

  66. //
    67. 

  67. #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    68. 

  68. # define BOOST_RANDOM_PTR_HELPER_SPEC(T)                \
    69. 

  69. namespace boost { namespace random { namespace detail { \
    70. 

  70. template<>                                              \
    71. 

  71. struct ptr_helper<T&>                                   \
    72. 

  72. {                                                       \
    73. 

  73.   typedef T value_type;                                 \
    74. 

  74.   typedef T& reference_type;                            \
    75. 

  75.   typedef T& rvalue_type;                               \
    76. 

  76.   static reference_type ref(T& r) { return r; }         \
    77. 

  77.   static const T& ref(const T& r) { return r; }         \
    78. 

  78. };                                                      \
    79. 

  79.                                                         \
    80. 

  80. template<>                                              \
    81. 

  81. struct ptr_helper<T*>                                   \
    82. 

  82. {                                                       \
    83. 

  83.   typedef T value_type;                                 \
    84. 

  84.   typedef T& reference_type;                            \
    85. 

  85.   typedef T* rvalue_type;                               \
    86. 

  86.   static reference_type ref(T * p) { return *p; }       \
    87. 

  87.   static const T& ref(const T * p) { return *p; }       \
    88. 

  88. };                                                      \
    89. 

  89. }}}
    90. 

  90. #else
    91. 

  91. # define BOOST_RANDOM_PTR_HELPER_SPEC(T)
    92. 

  92. #endif 
    93. 

  93. 

  94. #endif // BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
    95.