forked from boostorg/unordered
148 lines
4.1 KiB
C++
148 lines
4.1 KiB
C++
|
|
// Copyright 2009 Daniel James.
|
|
// 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/prefix.hpp"
|
|
|
|
#include <boost/unordered_map.hpp>
|
|
#include <boost/unordered_set.hpp>
|
|
|
|
namespace x
|
|
{
|
|
struct D { boost::unordered_map<D, D> x; };
|
|
}
|
|
|
|
namespace test
|
|
{
|
|
// Declare, but don't define some types.
|
|
|
|
struct value;
|
|
struct hash;
|
|
struct equals;
|
|
template <class T>
|
|
struct malloc_allocator;
|
|
|
|
// Declare some instances
|
|
|
|
typedef boost::unordered_map<value, value, hash, equals,
|
|
malloc_allocator<std::pair<value const, value> > > map;
|
|
typedef boost::unordered_multimap<value, value, hash, equals,
|
|
malloc_allocator<std::pair<value const, value> > > multimap;
|
|
typedef boost::unordered_set<value, hash, equals,
|
|
malloc_allocator<value> > set;
|
|
typedef boost::unordered_multiset<value, hash, equals,
|
|
malloc_allocator<value> > multiset;
|
|
|
|
// 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; }
|
|
};
|
|
|
|
}
|
|
|
|
#include "../helpers/allocator.hpp"
|
|
|
|
namespace test
|
|
{
|
|
// Declare some members of a structs.
|
|
//
|
|
// Incomplete hash, equals and allocator aren't here supported at the
|
|
// moment.
|
|
|
|
struct struct1 {
|
|
boost::unordered_map<struct1, struct1, hash, equals,
|
|
malloc_allocator<std::pair<struct1 const, struct1> > > x;
|
|
};
|
|
struct struct2 {
|
|
boost::unordered_multimap<struct2, struct2, hash, equals,
|
|
malloc_allocator<std::pair<struct2 const, struct2> > > x;
|
|
};
|
|
struct struct3 {
|
|
boost::unordered_set<struct3, hash, equals,
|
|
malloc_allocator<struct3> > x;
|
|
};
|
|
struct struct4 {
|
|
boost::unordered_multiset<struct4, hash, equals,
|
|
malloc_allocator<struct4> > x;
|
|
};
|
|
|
|
// Now define the value type.
|
|
|
|
struct value {};
|
|
|
|
// Create some instances.
|
|
|
|
test::map m1;
|
|
test::multimap m2;
|
|
test::set s1;
|
|
test::multiset s2;
|
|
|
|
test::struct1 c1;
|
|
test::struct2 c2;
|
|
test::struct3 c3;
|
|
test::struct4 c4;
|
|
|
|
// 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()
|
|
{
|
|
test::value x;
|
|
m1[x] = x;
|
|
m2.insert(std::make_pair(x, x));
|
|
s1.insert(x);
|
|
s2.insert(x);
|
|
|
|
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; }
|
|
}
|
|
|
|
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.
|
|
|
|
test::use_types();
|
|
}
|