cds/intrusive/details/node_traits.h

   1 /*
   2     This file is a part of libcds - Concurrent Data Structures library
   3
   4     (C) Copyright Maxim Khizhinsky (libcds.dev@gmail.com) 2006-2016
   5
   6     Source code repo: http://github.com/khizmax/libcds/
   7     Download: http://sourceforge.net/projects/libcds/files/
   8
   9     Redistribution and use in source and binary forms, with or without
  10     modification, are permitted provided that the following conditions are met:
  11
  12     * Redistributions of source code must retain the above copyright notice, this
  13       list of conditions and the following disclaimer.
  14
  15     * Redistributions in binary form must reproduce the above copyright notice,
  16       this list of conditions and the following disclaimer in the documentation
  17       and/or other materials provided with the distribution.
  18
  19     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20     AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21     IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  23     FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24     DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  25     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  26     CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  27     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #ifndef CDSLIB_INTRUSIVE_DETAILS_NODE_TRAITS_H
  32 #define CDSLIB_INTRUSIVE_DETAILS_NODE_TRAITS_H
  33
  34 #include <cds/intrusive/options.h>
  35
  36 namespace cds { namespace intrusive {
  37
  38 #ifdef CDS_DOXYGEN_INVOKED
  39     /// Container's node traits
  40     /** @ingroup cds_intrusive_helper
  41         This traits is intended for converting between type \p T of value stored in the intrusive container
  42         and container's node type \p NodeType.
  43
  44         There are separate specializations for each \p Hook type.
  45     */
  46     template <typename T, typename NodeType, typename Hook>
  47     struct node_traits
  48     {
  49         typedef T        value_type ;  ///< Value type
  50         typedef NodeType node_type  ;  ///< Node type
  51
  52         /// Convert value reference to node pointer
  53         static node_type * to_node_ptr( value_type& v );
  54
  55         /// Convert value pointer to node pointer
  56         static node_type * to_node_ptr( value_type * v );
  57
  58         /// Convert value reference to node pointer (const version)
  59         static const node_type * to_node_ptr( value_type const& v );
  60
  61         /// Convert value pointer to node pointer (const version)
  62         static const node_type * to_node_ptr( value_type const * v );
  63
  64         /// Convert node refernce to value pointer
  65         static value_type * to_value_ptr( node_type&  n );
  66
  67         /// Convert node pointer to value pointer
  68         static value_type * to_value_ptr( node_type *  n );
  69
  70         /// Convert node reference to value pointer (const version)
  71         static const value_type * to_value_ptr( node_type const & n );
  72
  73         /// Convert node pointer to value pointer (const version)
  74         static const value_type * to_value_ptr( node_type const * n );
  75     };
  76
  77 #else
  78     template <typename T, typename NodeType, class Hook, typename HookType>
  79     struct node_traits;
  80 #endif
  81
  82     //@cond
  83     template <typename T, typename NodeType, class Hook>
  84     struct node_traits<T, NodeType, Hook, opt::base_hook_tag>
  85     {
  86         typedef T        value_type;
  87         typedef NodeType node_type;
  88
  89         static node_type * to_node_ptr( value_type& v )
  90         {
  91             return static_cast<node_type *>( &v );
  92         }
  93         static node_type * to_node_ptr( value_type * v )
  94         {
  95             return v ? static_cast<node_type *>(v) : nullptr;
  96         }
  97         static const node_type * to_node_ptr( const value_type& v )
  98         {
  99             return static_cast<const node_type *>( &v );
 100         }
 101         static const node_type * to_node_ptr( const value_type * v )
 102         {
 103             return v ? static_cast<const node_type *>(v) : nullptr;
 104         }
 105         static value_type * to_value_ptr( node_type&  n )
 106         {
 107             return static_cast<value_type *>( &n );
 108         }
 109         static value_type * to_value_ptr( node_type *  n )
 110         {
 111             return n ? static_cast<value_type *>(n) : nullptr;
 112         }
 113         static const value_type * to_value_ptr( const node_type& n )
 114         {
 115             return static_cast<const value_type *>( &n );
 116         }
 117         static const value_type * to_value_ptr( const node_type * n )
 118         {
 119             return n ? static_cast<const value_type *>(n) : nullptr;
 120         }
 121     };
 122
 123     template <typename T, typename NodeType, class Hook>
 124     struct node_traits<T, NodeType, Hook, opt::member_hook_tag>
 125     {
 126         typedef T        value_type;
 127         typedef NodeType node_type;
 128
 129         static node_type * to_node_ptr( value_type& v )
 130         {
 131             return reinterpret_cast<node_type *>( reinterpret_cast<char *>(&v) + Hook::c_nMemberOffset );
 132         }
 133         static node_type * to_node_ptr( value_type * v )
 134         {
 135             return v ? to_node_ptr( *v ) : nullptr;
 136         }
 137         static const node_type * to_node_ptr( const value_type& v )
 138         {
 139             return reinterpret_cast<const node_type *>( reinterpret_cast<const char *>(&v) + Hook::c_nMemberOffset );
 140         }
 141         static const node_type * to_node_ptr( const value_type * v )
 142         {
 143             return v ? to_node_ptr( *v ) : nullptr;
 144         }
 145         static value_type * to_value_ptr( node_type& n )
 146         {
 147             return reinterpret_cast<value_type *>( reinterpret_cast<char *>(&n) - Hook::c_nMemberOffset );
 148         }
 149         static value_type * to_value_ptr( node_type * n )
 150         {
 151             return n ? to_value_ptr( *n ) : nullptr;
 152         }
 153         static const value_type * to_value_ptr( const node_type& n )
 154         {
 155             return reinterpret_cast<const value_type *>( reinterpret_cast<const char *>(&n) - Hook::c_nMemberOffset );
 156         }
 157         static const value_type * to_value_ptr( const node_type * n )
 158         {
 159             return n ? to_value_ptr( *n ) : nullptr;
 160         }
 161     };
 162
 163     template <typename T, typename NodeType, class Hook>
 164     struct node_traits<T, NodeType, Hook, opt::traits_hook_tag>: public Hook::node_traits
 165     {};
 166     //@endcond
 167
 168     /// Node traits selector metafunction
 169     /** @ingroup cds_intrusive_helper
 170         The metafunction selects appropriate \ref node_traits specialization based on value type \p T, node type \p NodeType, and hook type \p Hook.
 171     */
 172     template <typename T, typename NodeType, class Hook>
 173     struct get_node_traits
 174     {
 175         //@cond
 176         typedef node_traits<T, NodeType, Hook, typename Hook::hook_type> type;
 177         //@endcond
 178     };
 179
 180     //@cond
 181     /// Functor converting container's node type to value type
 182     //TODO: delete
 183     template <class Container>
 184     struct node_to_value {
 185         typename Container::value_type * operator()( typename Container::node_type * p ) const
 186         {
 187             typedef typename Container::node_traits node_traits;
 188             return node_traits::to_value_ptr( p );
 189         }
 190     };
 191     //@endcond
 192
 193 }} // namespace cds::intrusuve
 194
 195 #endif  // #ifndef CDSLIB_INTRUSIVE_DETAILS_NODE_TRAITS_H