forked from boostorg/unordered
joaquintides
09d6416755
* made boost::unordered_[multi](map|set)::[const_][local_]iterator instantiable with incomplete value_type * qualified name to avoid self-definition
299 lines
8.1 KiB
C++
299 lines
8.1 KiB
C++
|
|
// Copyright 2009 Daniel James.
|
|
// Copyright 2022-2023 Christian Mazakas.
|
|
// Copyright 2025 Joaquin M Lopez Munoz
|
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
#include "../helpers/unordered.hpp"
|
|
#ifdef BOOST_UNORDERED_CFOA_TESTS
|
|
#include <boost/unordered/concurrent_flat_set.hpp>
|
|
#include <boost/unordered/concurrent_flat_map.hpp>
|
|
#include <boost/unordered/concurrent_node_map.hpp>
|
|
#include <boost/unordered/concurrent_node_set.hpp>
|
|
#endif
|
|
|
|
|
|
#include <utility>
|
|
|
|
namespace x {
|
|
struct D
|
|
{
|
|
#if defined(BOOST_UNORDERED_CFOA_TESTS)
|
|
boost::concurrent_flat_map<D, D> x;
|
|
boost::concurrent_node_map<D, D> y;
|
|
#elif defined(BOOST_UNORDERED_FOA_TESTS)
|
|
boost::unordered_flat_map<D, D> x;
|
|
boost::unordered_node_map<D, D> y;
|
|
#else
|
|
boost::unordered_map<D, D> x;
|
|
#endif
|
|
};
|
|
} // namespace x
|
|
|
|
namespace incomplete_test {
|
|
// Declare, but don't define some types.
|
|
|
|
struct value;
|
|
struct hash;
|
|
struct equals;
|
|
template <class T> struct allocator;
|
|
|
|
// Declare some instances
|
|
|
|
#if defined(BOOST_UNORDERED_CFOA_TESTS)
|
|
typedef boost::concurrent_flat_map<value, value, hash, equals,
|
|
allocator<std::pair<value const, value> > >
|
|
map1;
|
|
typedef boost::concurrent_flat_set<value, hash, equals, allocator<value> > set1;
|
|
typedef boost::concurrent_node_map<value, value, hash, equals,
|
|
allocator<std::pair<value const, value> > >
|
|
map2;
|
|
typedef boost::concurrent_node_set<value, hash, equals, allocator<value> >
|
|
set2;
|
|
#elif defined(BOOST_UNORDERED_FOA_TESTS)
|
|
typedef boost::unordered_flat_map<value, value, hash, equals,
|
|
allocator<std::pair<value const, value> > >
|
|
map1;
|
|
typedef boost::unordered_flat_set<value, hash, equals, allocator<value> > set1;
|
|
typedef boost::unordered_node_map<value, value, hash, equals,
|
|
allocator<std::pair<value const, value> > >
|
|
map2;
|
|
typedef boost::unordered_node_set<value, hash, equals, allocator<value> >
|
|
set2;
|
|
#else
|
|
typedef boost::unordered_map<value, value, hash, equals,
|
|
allocator<std::pair<value const, value> > >
|
|
map1;
|
|
typedef boost::unordered_multimap<value, value, hash, equals,
|
|
allocator<std::pair<value const, value> > >
|
|
map2;
|
|
typedef boost::unordered_set<value, hash, equals, allocator<value> > set1;
|
|
typedef boost::unordered_multiset<value, hash, equals, allocator<value> >
|
|
set2;
|
|
#endif
|
|
|
|
// Now define the types which are stored as members, as they are needed for
|
|
// declaring struct members.
|
|
|
|
struct hash
|
|
{
|
|
template <typename T> std::size_t operator()(T const&) const { return 0; }
|
|
};
|
|
|
|
struct equals
|
|
{
|
|
template <typename T> bool operator()(T const&, T const&) const
|
|
{
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// This is a dubious way to implement an allocator, but good enough
|
|
// for this test.
|
|
template <typename T> struct allocator : std::allocator<T>
|
|
{
|
|
allocator() {}
|
|
|
|
template <typename T2>
|
|
allocator(const allocator<T2>& other) : std::allocator<T>(other)
|
|
{
|
|
}
|
|
|
|
template <typename T2>
|
|
allocator(const std::allocator<T2>& other) : std::allocator<T>(other)
|
|
{
|
|
}
|
|
};
|
|
|
|
// Declare some members of a structs.
|
|
//
|
|
// Incomplete hash, equals and allocator aren't here supported at the
|
|
// moment.
|
|
#ifdef BOOST_UNORDERED_FOA_TESTS
|
|
struct struct1
|
|
{
|
|
boost::unordered_flat_map<struct1, struct1, hash, equals,
|
|
allocator<std::pair<struct1 const, struct1> > >
|
|
x;
|
|
};
|
|
struct struct2
|
|
{
|
|
boost::unordered_node_map<struct2, struct2, hash, equals,
|
|
allocator<std::pair<struct2 const, struct2> > >
|
|
x;
|
|
};
|
|
struct struct3
|
|
{
|
|
boost::unordered_flat_set<struct3, hash, equals, allocator<struct3> > x;
|
|
};
|
|
struct struct4
|
|
{
|
|
boost::unordered_node_set<struct4, hash, equals, allocator<struct4> > x;
|
|
};
|
|
#else
|
|
struct struct1
|
|
{
|
|
boost::unordered_map<struct1, struct1, hash, equals,
|
|
allocator<std::pair<struct1 const, struct1> > >
|
|
x;
|
|
};
|
|
struct struct2
|
|
{
|
|
boost::unordered_multimap<struct2, struct2, hash, equals,
|
|
allocator<std::pair<struct2 const, struct2> > >
|
|
x;
|
|
};
|
|
struct struct3
|
|
{
|
|
boost::unordered_set<struct3, hash, equals, allocator<struct3> > x;
|
|
};
|
|
struct struct4
|
|
{
|
|
boost::unordered_multiset<struct4, hash, equals, allocator<struct4> > x;
|
|
};
|
|
#endif
|
|
|
|
// Create some instances.
|
|
|
|
incomplete_test::map1 m1;
|
|
#ifndef BOOST_UNORDERED_CFOA_TESTS
|
|
incomplete_test::map1::iterator itm1;
|
|
incomplete_test::map1::const_iterator citm1;
|
|
#ifndef BOOST_UNORDERED_FOA_TESTS
|
|
incomplete_test::map1::local_iterator litm1;
|
|
incomplete_test::map1::const_local_iterator clitm1;
|
|
#endif
|
|
#endif
|
|
|
|
incomplete_test::map2 m2;
|
|
#ifndef BOOST_UNORDERED_CFOA_TESTS
|
|
incomplete_test::map2::iterator itm2;
|
|
incomplete_test::map2::const_iterator citm2;
|
|
#ifndef BOOST_UNORDERED_FOA_TESTS
|
|
incomplete_test::map2::local_iterator litm2;
|
|
incomplete_test::map2::const_local_iterator clitm2;
|
|
#endif
|
|
#endif
|
|
|
|
incomplete_test::set1 s1;
|
|
#ifndef BOOST_UNORDERED_CFOA_TESTS
|
|
incomplete_test::set1::iterator its1;
|
|
incomplete_test::set1::const_iterator cits1;
|
|
#ifndef BOOST_UNORDERED_FOA_TESTS
|
|
incomplete_test::set1::local_iterator lits1;
|
|
incomplete_test::set1::const_local_iterator clits1;
|
|
#endif
|
|
#endif
|
|
|
|
incomplete_test::set2 s2;
|
|
#ifndef BOOST_UNORDERED_CFOA_TESTS
|
|
incomplete_test::set2::iterator its2;
|
|
incomplete_test::set2::const_iterator cits2;
|
|
#ifndef BOOST_UNORDERED_FOA_TESTS
|
|
incomplete_test::set2::local_iterator lits2;
|
|
incomplete_test::set2::const_local_iterator clits2;
|
|
#endif
|
|
#endif
|
|
|
|
incomplete_test::struct1 c1;
|
|
incomplete_test::struct2 c2;
|
|
incomplete_test::struct3 c3;
|
|
incomplete_test::struct4 c4;
|
|
|
|
// Now define the value type.
|
|
|
|
struct value
|
|
{
|
|
};
|
|
|
|
// Now declare, but don't define, the operators required for comparing
|
|
// elements.
|
|
|
|
std::size_t hash_value(value const&);
|
|
bool operator==(value const&, value const&);
|
|
|
|
std::size_t hash_value(struct1 const&);
|
|
std::size_t hash_value(struct2 const&);
|
|
std::size_t hash_value(struct3 const&);
|
|
std::size_t hash_value(struct4 const&);
|
|
|
|
bool operator==(struct1 const&, struct1 const&);
|
|
bool operator==(struct2 const&, struct2 const&);
|
|
bool operator==(struct3 const&, struct3 const&);
|
|
bool operator==(struct4 const&, struct4 const&);
|
|
|
|
// And finally use these
|
|
|
|
void use_types()
|
|
{
|
|
incomplete_test::value x;
|
|
m1.insert(std::make_pair(x, x));
|
|
#ifndef BOOST_UNORDERED_CFOA_TESTS
|
|
itm1 = m1.begin();
|
|
citm1 = m1.cbegin();
|
|
#ifndef BOOST_UNORDERED_FOA_TESTS
|
|
litm1 = m1.begin(0);
|
|
clitm1 = m1.cbegin(0);
|
|
#endif
|
|
#endif
|
|
|
|
m2.insert(std::make_pair(x, x));
|
|
#ifndef BOOST_UNORDERED_CFOA_TESTS
|
|
itm2 = m2.begin();
|
|
citm2 = m2.cbegin();
|
|
#ifndef BOOST_UNORDERED_FOA_TESTS
|
|
litm2 = m2.begin(0);
|
|
clitm2 = m2.cbegin(0);
|
|
#endif
|
|
#endif
|
|
|
|
s1.insert(x);
|
|
#ifndef BOOST_UNORDERED_CFOA_TESTS
|
|
its1 = s1.begin();
|
|
cits1 = s1.cbegin();
|
|
#ifndef BOOST_UNORDERED_FOA_TESTS
|
|
lits1 = s1.begin(0);
|
|
clits1 = s1.cbegin(0);
|
|
#endif
|
|
#endif
|
|
|
|
s2.insert(x);
|
|
#ifndef BOOST_UNORDERED_CFOA_TESTS
|
|
its2 = s2.begin();
|
|
cits2 = s2.cbegin();
|
|
#ifndef BOOST_UNORDERED_FOA_TESTS
|
|
lits2 = s2.begin(0);
|
|
clits2 = s2.cbegin(0);
|
|
#endif
|
|
#endif
|
|
c1.x.insert(std::make_pair(c1, c1));
|
|
c2.x.insert(std::make_pair(c2, c2));
|
|
c3.x.insert(c3);
|
|
c4.x.insert(c4);
|
|
}
|
|
|
|
// And finally define the operators required for comparing elements.
|
|
|
|
std::size_t hash_value(value const&) { return 0; }
|
|
bool operator==(value const&, value const&) { return true; }
|
|
|
|
std::size_t hash_value(struct1 const&) { return 0; }
|
|
std::size_t hash_value(struct2 const&) { return 0; }
|
|
std::size_t hash_value(struct3 const&) { return 0; }
|
|
std::size_t hash_value(struct4 const&) { return 0; }
|
|
|
|
bool operator==(struct1 const&, struct1 const&) { return true; }
|
|
bool operator==(struct2 const&, struct2 const&) { return true; }
|
|
bool operator==(struct3 const&, struct3 const&) { return true; }
|
|
bool operator==(struct4 const&, struct4 const&) { return true; }
|
|
} // namespace incomplete_test
|
|
|
|
int main()
|
|
{
|
|
// This could just be a compile test, but I like to be able to run these
|
|
// things. It's probably irrational, but I find it reassuring.
|
|
|
|
incomplete_test::use_types();
|
|
}
|