Mirrors/bx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bx.git synced 2026-02-17 20:52:37 +01:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Update TinySTL. (#340)"

Browse Source 
This reverts commit 2a03cec5d6.
This commit is contained in:
Бранимир Караџић
2025-01-26 15:21:45 -08:00
parent b6f79884e3
commit 01c99ddd09
13 changed files with 205 additions and 626 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
include/tinystl/unordered_map.h
View File

@@ -1,5 +1,5 @@
/*-
* Copyright 2012-2018 Matthew Endsley
* Copyright 2012 Matthew Endsley
* All rights reserved
*
* Redistribution and use in source and binary forms, with or without
@@ -27,10 +27,9 @@
#ifndef TINYSTL_UNORDERED_MAP_H
#define TINYSTL_UNORDERED_MAP_H
#include <tinystl/allocator.h>
#include <tinystl/buffer.h>
#include <tinystl/hash.h>
#include <tinystl/hash_base.h>
#include "buffer.h"
#include "hash.h"
#include "hash_base.h"
namespace tinystl {
@@ -39,14 +38,13 @@ namespace tinystl {
public:
unordered_map();
unordered_map(const unordered_map& other);
unordered_map(unordered_map&& other);
~unordered_map();
unordered_map& operator=(const unordered_map& other);
unordered_map& operator=(unordered_map&& other);
typedef pair<Key, Value> value_type;
typedef unordered_hash_iterator<const unordered_hash_node<Key, Value> > const_iterator;
typedef unordered_hash_iterator<unordered_hash_node<Key, Value> > iterator;
@@ -63,7 +61,6 @@ namespace tinystl {
const_iterator find(const Key& key) const;
iterator find(const Key& key);
pair<iterator, bool> insert(const pair<Key, Value>& p);
pair<iterator, bool> emplace(pair<Key, Value>&& p);
void erase(const_iterator where);
Value& operator[](const Key& key);
@@ -72,23 +69,22 @@ namespace tinystl {
private:
void rehash(size_t nbuckets);
typedef unordered_hash_node<Key, Value>* pointer;
size_t m_size;
tinystl::buffer<pointer, Alloc> m_buckets;
buffer<pointer, Alloc> m_buckets;
};
template<typename Key, typename Value, typename Alloc>
inline unordered_map<Key, Value, Alloc>::unordered_map()
unordered_map<Key, Value, Alloc>::unordered_map()
: m_size(0)
{
buffer_init<pointer, Alloc>(&m_buckets);
buffer_resize<pointer, Alloc>(&m_buckets, 9, 0);
}
template<typename Key, typename Value, typename Alloc>
inline unordered_map<Key, Value, Alloc>::unordered_map(const unordered_map& other)
unordered_map<Key, Value, Alloc>::unordered_map(const unordered_map& other)
: m_size(other.m_size)
{
const size_t nbuckets = (size_t)(other.m_buckets.last - other.m_buckets.first);
@@ -104,32 +100,17 @@ namespace tinystl {
}
template<typename Key, typename Value, typename Alloc>
inline unordered_map<Key, Value, Alloc>::unordered_map(unordered_map&& other)
: m_size(other.m_size)
{
buffer_move(&m_buckets, &other.m_buckets);
other.m_size = 0;
}
template<typename Key, typename Value, typename Alloc>
inline unordered_map<Key, Value, Alloc>::~unordered_map() {
if (m_buckets.first != m_buckets.last)
clear();
unordered_map<Key, Value, Alloc>::~unordered_map() {
clear();
buffer_destroy<pointer, Alloc>(&m_buckets);
}
template<typename Key, typename Value, typename Alloc>
inline unordered_map<Key, Value, Alloc>& unordered_map<Key, Value, Alloc>::operator=(const unordered_map<Key, Value, Alloc>& other) {
unordered_map<Key, Value, Alloc>& unordered_map<Key, Value, Alloc>::operator=(const unordered_map<Key, Value, Alloc>& other) {
unordered_map<Key, Value, Alloc>(other).swap(*this);
return *this;
}
template<typename Key, typename Value, typename Alloc>
inline unordered_map<Key, Value, Alloc>& unordered_map<Key, Value, Alloc>::operator=(unordered_map&& other) {
unordered_map(static_cast<unordered_map&&>(other)).swap(*this);
return *this;
}
template<typename Key, typename Value, typename Alloc>
inline typename unordered_map<Key, Value, Alloc>::iterator unordered_map<Key, Value, Alloc>::begin() {
iterator it;
@@ -199,10 +180,24 @@ namespace tinystl {
}
template<typename Key, typename Value, typename Alloc>
inline void unordered_map<Key, Value, Alloc>::rehash(size_t nbuckets) {
inline pair<typename unordered_map<Key, Value, Alloc>::iterator, bool> unordered_map<Key, Value, Alloc>::insert(const pair<Key, Value>& p) {
pair<iterator, bool> result;
result.second = false;
result.first = find(p.first);
if (result.first.node != 0)
return result;
unordered_hash_node<Key, Value>* newnode = new(placeholder(), Alloc::static_allocate(sizeof(unordered_hash_node<Key, Value>))) unordered_hash_node<Key, Value>(p.first, p.second);
newnode->next = newnode->prev = 0;
const size_t nbuckets = (size_t)(m_buckets.last - m_buckets.first);
unordered_hash_node_insert(newnode, hash(p.first), m_buckets.first, nbuckets - 1);
++m_size;
if (m_size + 1 > 4 * nbuckets) {
pointer root = *m_buckets.first;
const size_t newnbuckets = ((size_t)(m_buckets.last - m_buckets.first) - 1) * 8;
m_buckets.last = m_buckets.first;
buffer_resize<pointer, Alloc>(&m_buckets, newnbuckets + 1, 0);
@@ -215,26 +210,6 @@ namespace tinystl {
root = next;
}
}
}
template<typename Key, typename Value, typename Alloc>
inline pair<typename unordered_map<Key, Value, Alloc>::iterator, bool> unordered_map<Key, Value, Alloc>::insert(const pair<Key, Value>& p) {
pair<iterator, bool> result;
result.second = false;
result.first = find(p.first);
if (result.first.node != 0)
return result;
unordered_hash_node<Key, Value>* newnode = new(placeholder(), Alloc::static_allocate(sizeof(unordered_hash_node<Key, Value>))) unordered_hash_node<Key, Value>(p.first, p.second);
newnode->next = newnode->prev = 0;
if(!m_buckets.first) buffer_resize<pointer, Alloc>(&m_buckets, 9, 0);
const size_t nbuckets = (size_t)(m_buckets.last - m_buckets.first);
unordered_hash_node_insert(newnode, hash(p.first), m_buckets.first, nbuckets - 1);
++m_size;
rehash(nbuckets);
result.first.node = newnode;
result.second = true;
@@ -242,32 +217,7 @@ namespace tinystl {
}
template<typename Key, typename Value, typename Alloc>
inline pair<typename unordered_map<Key, Value, Alloc>::iterator, bool> unordered_map<Key, Value, Alloc>::emplace(pair<Key, Value>&& p) {
pair<iterator, bool> result;
result.second = false;
result.first = find(p.first);
if (result.first.node != 0)
return result;
const size_t keyhash = hash(p.first);
unordered_hash_node<Key, Value>* newnode = new(placeholder(), Alloc::static_allocate(sizeof(unordered_hash_node<Key, Value>))) unordered_hash_node<Key, Value>(static_cast<Key&&>(p.first), static_cast<Value&&>(p.second));
newnode->next = newnode->prev = 0;
if (!m_buckets.first) buffer_resize<pointer, Alloc>(&m_buckets, 9, 0);
const size_t nbuckets = (size_t)(m_buckets.last - m_buckets.first);
unordered_hash_node_insert(newnode, keyhash, m_buckets.first, nbuckets - 1);
++m_size;
rehash(nbuckets);
result.first.node = newnode;
result.second = true;
return result;
}
template<typename Key, typename Value, typename Alloc>
inline void unordered_map<Key, Value, Alloc>::erase(const_iterator where) {
void unordered_map<Key, Value, Alloc>::erase(const_iterator where) {
unordered_hash_node_erase(where.node, hash(where->first), m_buckets.first, (size_t)(m_buckets.last - m_buckets.first) - 1);
where->~unordered_hash_node<Key, Value>();
@@ -276,12 +226,12 @@ namespace tinystl {
}
template<typename Key, typename Value, typename Alloc>
inline Value& unordered_map<Key, Value, Alloc>::operator[](const Key& key) {
Value& unordered_map<Key, Value, Alloc>::operator[](const Key& key) {
return insert(pair<Key, Value>(key, Value())).first->second;
}
template<typename Key, typename Value, typename Alloc>
inline void unordered_map<Key, Value, Alloc>::swap(unordered_map& other) {
void unordered_map<Key, Value, Alloc>::swap(unordered_map& other) {
size_t tsize = other.m_size;
other.m_size = m_size, m_size = tsize;
buffer_swap(&m_buckets, &other.m_buckets);