cds/container/details/feldman_hashset_base.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_CONTAINER_DETAILS_FELDMAN_HASHSET_BASE_H
  32 #define CDSLIB_CONTAINER_DETAILS_FELDMAN_HASHSET_BASE_H
  33
  34 #include <cds/intrusive/details/feldman_hashset_base.h>
  35 #include <cds/container/details/base.h>
  36
  37 namespace cds { namespace container {
  38     /// \p FeldmanHashSet related definitions
  39     /** @ingroup cds_nonintrusive_helper
  40     */
  41     namespace feldman_hashset {
  42         /// Hash accessor option
  43         /**
  44             @copydetails cds::intrusive::feldman_hashset::traits::hash_accessor
  45         */
  46         template <typename Accessor>
  47         using hash_accessor = cds::intrusive::feldman_hashset::hash_accessor< Accessor >;
  48
  49         /// Hash size option
  50         /**
  51             @copydetails cds::intrusive::feldman_hashset::traits::hash_size
  52         */
  53         template <size_t Size>
  54         using hash_size = cds::intrusive::feldman_hashset::hash_size< Size >;
  55
  56         /// \p FeldmanHashSet internal statistics, see cds::intrusive::feldman_hashset::stat
  57         template <typename EventCounter = cds::atomicity::event_counter>
  58         using stat = cds::intrusive::feldman_hashset::stat< EventCounter >;
  59
  60         /// \p FeldmanHashSet empty internal statistics
  61         typedef cds::intrusive::feldman_hashset::empty_stat empty_stat;
  62
  63         /// Bit-wise memcmp-based comparator for hash value \p T
  64         template <typename T>
  65         using bitwise_compare = cds::intrusive::feldman_hashset::bitwise_compare< T >;
  66
  67         /// \p FeldmanHashSet level statistics
  68         typedef cds::intrusive::feldman_hashset::level_statistics level_statistics;
  69
  70         /// \p FeldmanHashSet traits
  71         struct traits
  72         {
  73             /// Mandatory functor to get hash value from data node
  74             /**
  75                 @copydetails cds::intrusive::feldman_hashset::traits::hash_accessor
  76             */
  77             typedef cds::opt::none hash_accessor;
  78
  79             /// The size of hash value in bytes
  80             /**
  81                 @copydetails cds::intrusive::feldman_hashset::traits::hash_size
  82             */
  83             enum : size_t {
  84                 hash_size = 0
  85             };
  86
  87             /// Hash comparing functor
  88             /**
  89                 @copydetails cds::intrusive::feldman_hashset::traits::compare
  90             */
  91             typedef cds::opt::none compare;
  92
  93             /// Specifies binary predicate used for hash compare.
  94             /**
  95                 @copydetails cds::intrusive::feldman_hashset::traits::less
  96             */
  97             typedef cds::opt::none less;
  98
  99             /// Item counter
 100             /**
 101                 @copydetails cds::intrusive::feldman_hashset::traits::item_counter
 102             */
 103             typedef cds::atomicity::item_counter item_counter;
 104
 105             /// Item allocator
 106             /**
 107                 Default is \ref CDS_DEFAULT_ALLOCATOR
 108             */
 109             typedef CDS_DEFAULT_ALLOCATOR allocator;
 110
 111             /// Array node allocator
 112             /**
 113                 @copydetails cds::intrusive::feldman_hashset::traits::node_allocator
 114             */
 115             typedef CDS_DEFAULT_ALLOCATOR node_allocator;
 116
 117             /// C++ memory ordering model
 118             /**
 119                 @copydetails cds::intrusive::feldman_hashset::traits::memory_model
 120             */
 121             typedef cds::opt::v::relaxed_ordering memory_model;
 122
 123             /// Back-off strategy
 124             typedef cds::backoff::Default back_off;
 125
 126             /// Internal statistics
 127             /**
 128                 @copydetails cds::intrusive::feldman_hashset::traits::stat
 129             */
 130             typedef empty_stat stat;
 131
 132             /// RCU deadlock checking policy (only for \ref cds_container_FeldmanHashSet_rcu "RCU-based FeldmanHashSet")
 133             /**
 134                 @copydetails cds::intrusive::feldman_hashset::traits::rcu_check_deadlock
 135             */
 136             typedef cds::opt::v::rcu_throw_deadlock rcu_check_deadlock;
 137         };
 138
 139         /// Metafunction converting option list to \p feldman_hashset::traits
 140         /**
 141             Supported \p Options are:
 142             - \p feldman_hashset::hash_accessor - mandatory option, hash accessor functor.
 143                 @copydetails traits::hash_accessor
 144             - \p feldman_hashset::hash_size - the size of hash value in bytes.
 145                 @copydetails traits::hash_size
 146             - \p opt::allocator - item allocator
 147                 @copydetails traits::allocator
 148             - \p opt::node_allocator - array node allocator.
 149                 @copydetails traits::node_allocator
 150             - \p opt::compare - hash comparison functor. No default functor is provided.
 151                 If the option is not specified, the \p opt::less is used.
 152             - \p opt::less - specifies binary predicate used for hash comparison.
 153                 @copydetails cds::container::feldman_hashset::traits::less
 154             - \p opt::back_off - back-off strategy used. If the option is not specified, the \p cds::backoff::Default is used.
 155             - \p opt::item_counter - the type of item counting feature.
 156                 @copydetails cds::intrusive::feldman_hashset::traits::item_counter
 157             - \p opt::memory_model - C++ memory ordering model. Can be \p opt::v::relaxed_ordering (relaxed memory model, the default)
 158                 or \p opt::v::sequential_consistent (sequentially consisnent memory model).
 159             - \p opt::stat - internal statistics. By default, it is disabled (\p feldman_hashset::empty_stat).
 160                 To enable it use \p feldman_hashset::stat
 161             - \p opt::rcu_check_deadlock - a deadlock checking policy for \ref cds_intrusive_FeldmanHashSet_rcu "RCU-based FeldmanHashSet"
 162                 Default is \p opt::v::rcu_throw_deadlock
 163         */
 164         template <typename... Options>
 165         struct make_traits
 166         {
 167 #   ifdef CDS_DOXYGEN_INVOKED
 168             typedef implementation_defined type ;   ///< Metafunction result
 169 #   else
 170             typedef typename cds::opt::make_options<
 171                 typename cds::opt::find_type_traits< traits, Options... >::type
 172                 ,Options...
 173             >::type   type;
 174 #   endif
 175         };
 176     } // namespace feldman_hashset
 177
 178     //@cond
 179     // Forward declaration
 180     template < class GC, typename T, class Traits = cds::container::feldman_hashset::traits >
 181     class FeldmanHashSet;
 182     //@endcond
 183
 184     //@cond
 185     namespace details {
 186
 187         template <typename GC, typename T, typename Traits>
 188         struct make_feldman_hashset
 189         {
 190             typedef GC      gc;
 191             typedef T       value_type;
 192             typedef Traits  original_traits;
 193
 194             typedef cds::details::Allocator< value_type, typename original_traits::allocator > cxx_node_allocator;
 195
 196             struct node_disposer
 197             {
 198                 void operator()( value_type * p ) const
 199                 {
 200                     cxx_node_allocator().Delete( p );
 201                 }
 202             };
 203
 204             struct intrusive_traits: public original_traits
 205             {
 206                 typedef node_disposer disposer;
 207             };
 208
 209             // Metafunction result
 210             typedef cds::intrusive::FeldmanHashSet< GC, T, intrusive_traits > type;
 211         };
 212     } // namespace details
 213     //@endcond
 214
 215 }} // namespace cds::container
 216
 217 #endif // #ifndef CDSLIB_CONTAINER_DETAILS_FELDMAN_HASHSET_BASE_H