UnorderedContainers.h

#pragma once
 
#include <xrpl/basics/hardened_hash.h>
#include <xrpl/basics/partitioned_unordered_map.h>
#include <xrpl/beast/hash/hash_append.h>
#include <xrpl/beast/hash/uhash.h>
#include <xrpl/beast/hash/xxhasher.h>
 
#include <unordered_map>
#include <unordered_set>
 
namespace xrpl {
 
// hash containers
 
template <
    class Key,
    class Value,
    class Hash = beast::uhash<>,
    class Pred = std::equal_to<Key>,
    class Allocator = std::allocator<std::pair<Key const, Value>>>
using hash_map = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
 
template <
    class Key,
    class Value,
    class Hash = beast::uhash<>,
    class Pred = std::equal_to<Key>,
    class Allocator = std::allocator<std::pair<Key const, Value>>>
using hash_multimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
 
template <
    class Value,
    class Hash = beast::uhash<>,
    class Pred = std::equal_to<Value>,
    class Allocator = std::allocator<Value>>
using hash_set = std::unordered_set<Value, Hash, Pred, Allocator>;
 
template <
    class Value,
    class Hash = beast::uhash<>,
    class Pred = std::equal_to<Value>,
    class Allocator = std::allocator<Value>>
using hash_multiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;
 
// hardened_hash containers
 
using strong_hash = beast::xxhasher;
 
template <
    class Key,
    class Value,
    class Hash = hardened_hash<strong_hash>,
    class Pred = std::equal_to<Key>,
    class Allocator = std::allocator<std::pair<Key const, Value>>>
using hardened_hash_map = std::unordered_map<Key, Value, Hash, Pred, Allocator>;
 
template <
    class Key,
    class Value,
    class Hash = hardened_hash<strong_hash>,
    class Pred = std::equal_to<Key>,
    class Allocator = std::allocator<std::pair<Key const, Value>>>
using hardened_partitioned_hash_map = partitioned_unordered_map<Key, Value, Hash, Pred, Allocator>;
 
template <
    class Key,
    class Value,
    class Hash = hardened_hash<strong_hash>,
    class Pred = std::equal_to<Key>,
    class Allocator = std::allocator<std::pair<Key const, Value>>>
using hardened_hash_multimap = std::unordered_multimap<Key, Value, Hash, Pred, Allocator>;
 
template <
    class Value,
    class Hash = hardened_hash<strong_hash>,
    class Pred = std::equal_to<Value>,
    class Allocator = std::allocator<Value>>
using hardened_hash_set = std::unordered_set<Value, Hash, Pred, Allocator>;
 
template <
    class Value,
    class Hash = hardened_hash<strong_hash>,
    class Pred = std::equal_to<Value>,
    class Allocator = std::allocator<Value>>
using hardened_hash_multiset = std::unordered_multiset<Value, Hash, Pred, Allocator>;
 
}  // namespace xrpl