kakoune/src/unordered_map.hh

#ifndef unordered_map_hh_INCLUDED
#define unordered_map_hh_INCLUDED

#include "hash.hh"
#include "memory.hh"

#include <unordered_map>
#include <unordered_set>

namespace Kakoune
{

template<typename Key, typename Value, MemoryDomain domain = TypeDomain<Key>::domain()>
using UnorderedMap = std::unordered_map<Key, Value, Hash<Key>, std::equal_to<Key>,
                                        Allocator<std::pair<const Key, Value>, domain>>;

template<typename Key, MemoryDomain domain = TypeDomain<Key>::domain()>
using UnorderedSet = std::unordered_set<Key, Hash<Key>, std::equal_to<Key>,
                                        Allocator<Key, domain>>;

}

#endif // unordered_map_hh_INCLUDED
Rework hashing, use a more extensible framework similar to n3876 proposal std::hash specialization is a pain to work with, stop using that, and just specialize a 'size_t hash_value(const T&)' free function. 2014-12-16 19:57:19 +01:00			`#ifndef unordered_map_hh_INCLUDED`
			`#define unordered_map_hh_INCLUDED`

			`#include "hash.hh"`
Add initial memory domain allocation tracking support 2015-01-07 20:29:31 +01:00			`#include "memory.hh"`
Rework hashing, use a more extensible framework similar to n3876 proposal std::hash specialization is a pain to work with, stop using that, and just specialize a 'size_t hash_value(const T&)' free function. 2014-12-16 19:57:19 +01:00
			`#include <unordered_map>`
Use an UnorderedSet for string registry 2015-04-16 13:38:59 +02:00			`#include <unordered_set>`
Rework hashing, use a more extensible framework similar to n3876 proposal std::hash specialization is a pain to work with, stop using that, and just specialize a 'size_t hash_value(const T&)' free function. 2014-12-16 19:57:19 +01:00
			`namespace Kakoune`
			`{`

Try to fix travis compilation errors 2015-01-21 14:35:23 +01:00			`template<typename Key, typename Value, MemoryDomain domain = TypeDomain<Key>::domain()>`
Add initial memory domain allocation tracking support 2015-01-07 20:29:31 +01:00			`using UnorderedMap = std::unordered_map<Key, Value, Hash<Key>, std::equal_to<Key>,`
			`Allocator<std::pair<const Key, Value>, domain>>;`
Rework hashing, use a more extensible framework similar to n3876 proposal std::hash specialization is a pain to work with, stop using that, and just specialize a 'size_t hash_value(const T&)' free function. 2014-12-16 19:57:19 +01:00
Use an UnorderedSet for string registry 2015-04-16 13:38:59 +02:00			`template<typename Key, MemoryDomain domain = TypeDomain<Key>::domain()>`
			`using UnorderedSet = std::unordered_set<Key, Hash<Key>, std::equal_to<Key>,`
Fix UnorderedSet allocator 2015-04-17 00:46:26 +02:00			`Allocator<Key, domain>>;`
Use an UnorderedSet for string registry 2015-04-16 13:38:59 +02:00
Rework hashing, use a more extensible framework similar to n3876 proposal std::hash specialization is a pain to work with, stop using that, and just specialize a 'size_t hash_value(const T&)' free function. 2014-12-16 19:57:19 +01:00			`}`

			`#endif // unordered_map_hh_INCLUDED`