UnorderedContainers.h

#pragma once
 
#include <xrpl/basics/hardened_hash.h>
#include <xrpl/basics/partitioned_unordered_map.h>
#include <xrpl/beast/hash/uhash.h>
#include <xrpl/beast/hash/xxhasher.h>
 
#include <functional>
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <utility>

 
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 = HardenedHash<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 = HardenedHash<strong_hash>,
    class Pred = std::equal_to<Key>,
    class Allocator = std::allocator<std::pair<Key const, Value>>>
using hardened_partitioned_hash_map = PartitionedUnorderedMap<Key, Value, Hash, Pred, Allocator>;
 
template <
    class Key,
    class Value,
    class Hash = HardenedHash<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 = HardenedHash<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 = HardenedHash<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