libstdc++-v3/testsuite/util/performance/assoc/multimap_common_type.hpp

   1 // -*- C++ -*-
   2
   3 // Copyright (C) 2005, 2006 Free Software Foundation, Inc.
   4 //
   5 // This file is part of the GNU ISO C++ Library.  This library is free
   6 // software; you can redistribute it and/or modify it under the terms
   7 // of the GNU General Public License as published by the Free Software
   8 // Foundation; either version 2, or (at your option) any later
   9 // version.
  10
  11 // This library is distributed in the hope that it will be useful, but
  12 // WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 // General Public License for more details.
  15
  16 // You should have received a copy of the GNU General Public License
  17 // along with this library; see the file COPYING.  If not, write to
  18 // the Free Software Foundation, 59 Temple Place - Suite 330, Boston,
  19 // MA 02111-1307, USA.
  20
  21 // As a special exception, you may use this file as part of a free
  22 // software library without restriction.  Specifically, if other files
  23 // instantiate templates or use macros or inline functions from this
  24 // file, or you compile this file and link it with other files to
  25 // produce an executable, this file does not by itself cause the
  26 // resulting executable to be covered by the GNU General Public
  27 // License.  This exception does not however invalidate any other
  28 // reasons why the executable file might be covered by the GNU General
  29 // Public License.
  30
  31 // Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL.
  32
  33 // Permission to use, copy, modify, sell, and distribute this software
  34 // is hereby granted without fee, provided that the above copyright
  35 // notice appears in all copies, and that both that copyright notice
  36 // and this permission notice appear in supporting documentation. None
  37 // of the above authors, nor IBM Haifa Research Laboratories, make any
  38 // representation about the suitability of this software for any
  39 // purpose. It is provided "as is" without express or implied
  40 // warranty.
  41
  42 /**
  43  * @file multimap_common_type.hpp
  44  * Contains types for a generic multimap_insert_test test.
  45  */
  46
  47 #ifndef PB_DS_MULTIMAP_RANDOM_INT_INSERT_TEST_COMMON_TYPE_HPP
  48 #define PB_DS_MULTIMAP_RANDOM_INT_INSERT_TEST_COMMON_TYPE_HPP
  49
  50 #include <hash_fn/string_hash_fn.hpp>
  51 #include <common_type/assoc/common_type.hpp>
  52
  53 namespace __gnu_pbds
  54 {
  55   namespace test
  56   {
  57     namespace detail
  58     {
  59       struct int_hash : public std::unary_function<int, size_t>
  60       {
  61         inline size_t
  62         operator()(const int i) const
  63         { return (static_cast<size_t>(i)); }
  64       };
  65
  66       template<typename Key, typename Allocator = std::allocator<char> >
  67       struct hash_set_tl_t
  68       {
  69         typedef
  70         typename __gnu_pbds::test::hash_common_types<
  71           Key,
  72           __gnu_pbds::null_mapped_type,
  73           int_hash,
  74           std::equal_to<Key>,
  75           Allocator>::performance_min_tl
  76         type;
  77       };
  78
  79       template<typename Key, typename Allocator = std::allocator<char> >
  80       struct lu_set_tl_t
  81       {
  82         typedef
  83         typename __gnu_pbds::test::lu_common_types<
  84           Key,
  85           __gnu_pbds::null_mapped_type,
  86           std::equal_to<
  87           Key>,
  88           Allocator>::performance_min_tl
  89         type;
  90       };
  91
  92       template<typename Key,
  93                class Sec_Tl,
  94                typename Allocator = std::allocator<char> >
  95       struct hash_mmap_tl_t
  96       {
  97       private:
  98         typedef
  99         typename __gnu_pbds::detail::__conditional_type<
 100         __gnu_pbds::detail::is_same<
 101         int,
 102         Key>::value,
 103         int_hash,
 104         string_hash_fn>::__type
 105         hash_fn_t;
 106
 107         template<typename Cntnr_T>
 108         struct hash_mmap_transform
 109         {
 110           typedef
 111           typename __gnu_pbds::test::hash_common_types<
 112             Key,
 113             Cntnr_T,
 114             hash_fn_t,
 115             std::equal_to<
 116             Key>,
 117             Allocator>::performance_min_tl
 118           type;
 119         };
 120
 121       public:
 122         typedef
 123         typename __gnu_cxx::typelist::flatten<
 124         typename __gnu_cxx::typelist::transform<
 125         Sec_Tl,
 126         hash_mmap_transform>::type>::type
 127         type;
 128       };
 129
 130       template<typename Key,
 131                class Sec_Tl,
 132                typename Allocator = std::allocator<char> >
 133       struct tree_mmap_tl_t
 134       {
 135       private:
 136         template<typename Cntnr_T>
 137         struct tree_mmap_transform
 138         {
 139           typedef
 140           typename __gnu_pbds::test::tree_common_types<
 141             Key,
 142             Cntnr_T,
 143             std::less<
 144             Key>,
 145             __gnu_pbds::null_tree_node_update,
 146             Allocator>::performance_min_tl
 147           type;
 148         };
 149
 150       public:
 151         typedef
 152         typename __gnu_cxx::typelist::flatten<
 153         typename __gnu_cxx::typelist::transform<
 154         Sec_Tl,
 155         tree_mmap_transform>::type>::type
 156         type;
 157       };
 158
 159       template<typename Key, typename Mapped, typename Allocator>
 160       struct hash_hash_mmap_tl_t
 161       {
 162       private:
 163         typedef typename hash_set_tl_t<Mapped, Allocator>::type sec_tl_t;
 164
 165       public:
 166         typedef typename hash_mmap_tl_t<Key, sec_tl_t, Allocator>::type type;
 167       };
 168
 169       template<typename Key, typename Mapped, typename Allocator>
 170       struct tree_hash_mmap_tl_t
 171       {
 172       private:
 173         typedef typename hash_set_tl_t<Mapped, Allocator>::type sec_tl_t;
 174
 175       public:
 176         typedef typename tree_mmap_tl_t<Key, sec_tl_t, Allocator>::type type;
 177       };
 178
 179       template<typename Key, typename Mapped, typename Allocator>
 180       struct tree_lu_mmap_tl_t
 181       {
 182       private:
 183         typedef typename lu_set_tl_t<Mapped, Allocator>::type sec_tl_t;
 184
 185       public:
 186         typedef typename tree_mmap_tl_t<Key, sec_tl_t, Allocator>::type type;
 187       };
 188
 189       template<typename Key, typename Mapped, typename Allocator>
 190       struct hash_lu_mmap_tl_t
 191       {
 192       private:
 193         typedef typename lu_set_tl_t<Mapped, Allocator>::type sec_tl_t;
 194
 195       public:
 196         typedef typename hash_mmap_tl_t<Key, sec_tl_t, Allocator>::type type;
 197       };
 198     } // namespace detail
 199
 200     template<typename Key, typename Mapped, typename Allocator>
 201     struct mmap_tl_t
 202     {
 203     private:
 204       typedef
 205       typename detail::hash_hash_mmap_tl_t<Key, Mapped, Allocator>::type
 206       hh_mmap_tl_t;
 207
 208       typedef
 209       typename detail::hash_lu_mmap_tl_t<Key, Mapped, Allocator>::type
 210       hl_mmap_tl_t;
 211
 212       typedef
 213       typename detail::tree_hash_mmap_tl_t<Key, Mapped, Allocator>::type
 214       th_mmap_tl_t;
 215
 216       typedef
 217       typename detail::tree_lu_mmap_tl_t<Key, Mapped, Allocator>::type
 218       tl_mmap_tl_t;
 219
 220     public:
 221       typedef
 222       typename __gnu_cxx::typelist::append<hl_mmap_tl_t,
 223       typename __gnu_cxx::typelist::append<hh_mmap_tl_t,
 224       typename __gnu_cxx::typelist::append<th_mmap_tl_t,
 225       tl_mmap_tl_t>::type>::type>::type
 226       type;
 227     };
 228
 229   } // namespace test
 230 } // namespace __gnu_pbds
 231
 232 #endif
 233