Fix many issues.

include/TINYSTL/buffer.h

@@ -203,7 +203,7 @@ namespace tinystl {
 	static inline T* buffer_insert_common(buffer<T, Alloc>* b, T* where, size_t count) {
 		const size_t offset = (size_t)(where - b->first);
 		const size_t newsize = (size_t)((b->last - b->first) + count);
-		if (b->first + newsize > b->capacity)
+		if (!b->first || b->first + newsize > b->capacity)
 			buffer_reserve(b, (newsize * 3) / 2);
 
 		where = b->first + offset;

include/TINYSTL/hash_base.h

@@ -45,6 +45,9 @@ namespace tinystl {
 
 		Key first;
 		Value second;
+
+		using first_type = Key;
+		using second_type = Value;
 	};
 
 	template<typename Key, typename Value>
@@ -94,9 +97,9 @@ namespace tinystl {
 	}
 
 	template<typename Key, typename Value>
-	static inline pair<typename remove_reference<Key>::type, typename remove_reference<Value>::type>
+	static inline pair<typename remove_const_reference<Key>::type, typename remove_const_reference<Value>::type>
 	make_pair(Key&& key, Value&& value) {
-		return pair<typename remove_reference<Key>::type, typename remove_reference<Value>::type>(
+		return pair<typename remove_const_reference<Key>::type, typename remove_const_reference<Value>::type>(
 				  static_cast<Key&&>(key)
 				, static_cast<Value&&>(value)
 			);
@@ -112,9 +115,6 @@ namespace tinystl {
 		Value second;
 		unordered_hash_node* next;
 		unordered_hash_node* prev;
-
-	private:
-		unordered_hash_node& operator=(const unordered_hash_node&);
 	};
 
 	template<typename Key, typename Value>
@@ -139,9 +139,6 @@ namespace tinystl {
 		const Key first;
 		unordered_hash_node* next;
 		unordered_hash_node* prev;
-
-	private:
-		unordered_hash_node& operator=(const unordered_hash_node&);
 	};
 
 	template<typename Key>

include/TINYSTL/string.h

@@ -66,7 +66,7 @@ namespace tinystl {
 		pointer m_capacity;
 
 		static const size_t c_nbuffer = 12;
-		char m_buffer[12];
+		char m_buffer[12]{0};
 	};
 
 	template<typename allocator>
@@ -157,15 +157,16 @@ namespace tinystl {
 	template<typename allocator>
 	inline size_t basic_string<allocator>::size() const
 	{
-		return (size_t)(m_last - m_first);
+		ptrdiff_t size = m_last - m_first;
+		return (size_t)size;
 	}
 
 	template<typename allocator>
 	inline void basic_string<allocator>::reserve(size_t capacity) {
 		if (m_first + capacity + 1 <= m_capacity)
 			return;
 
-		const size_t size = (size_t)(m_last - m_first);
+		const ptrdiff_t size = m_last - m_first;
 
 		pointer newfirst = (pointer)allocator::static_allocate(capacity + 1);
 		for (pointer it = m_first, newit = newfirst, end = m_last; it != end; ++it, ++newit)
@@ -180,9 +181,9 @@ namespace tinystl {
 
 	template<typename allocator>
 	inline void basic_string<allocator>::resize(size_t size) {
-		const size_t prevSize = m_last-m_first;
+		const ptrdiff_t prevSize = m_last-m_first;
 		reserve(size);
-		if (size > prevSize)
+		if (size > (size_t)prevSize)
 			for (pointer it = m_last, end = m_first + size + 1; it < end; ++it)
 				*it = 0;
 		else if (m_last != m_first)
@@ -198,7 +199,7 @@ namespace tinystl {
 
 	template<typename allocator>
 	inline void basic_string<allocator>::append(const char* first, const char* last) {
-		const size_t newsize = (size_t)((m_last - m_first) + (last - first) + 1);
+		const ptrdiff_t newsize = ((m_last - m_first) + (last - first) + 1);
 		if (m_first + newsize > m_capacity)
 			reserve((newsize * 3) / 2);
 
@@ -217,12 +218,12 @@ namespace tinystl {
 	inline void basic_string<allocator>::shrink_to_fit() {
 		if (m_first == m_buffer) {
 		} else if (m_last == m_first) {
-			const size_t capacity = (size_t)(m_capacity - m_first);
+			const ptrdiff_t capacity = m_capacity - m_first;
 			if (capacity)
 				allocator::static_deallocate(m_first, capacity+1);
 			m_capacity = m_first;
 		} else if (m_capacity != m_last) {
-			const size_t size = (size_t)(m_last - m_first);
+			const ptrdiff_t size = m_last - m_first;
 			char* newfirst = (pointer)allocator::static_allocate(size+1);
 			for (pointer in = m_first, out = newfirst; in != m_last + 1; ++in, ++out)
 				*out = *in;
@@ -236,34 +237,28 @@ namespace tinystl {
 
 	template<typename allocator>
 	inline void basic_string<allocator>::swap(basic_string& other) {
-		const pointer tfirst = m_first, tlast = m_last, tcapacity = m_capacity;
-		m_first = other.m_first, m_last = other.m_last, m_capacity = other.m_capacity;
-		other.m_first = tfirst, other.m_last = tlast, other.m_capacity = tcapacity;
-
-		char tbuffer[c_nbuffer];
-
-		if (m_first == other.m_buffer)
-			for  (pointer it = other.m_buffer, end = m_last, out = tbuffer; it != end; ++it, ++out)
-				*out = *it;
-
-		if (other.m_first == m_buffer) {
-			other.m_last = other.m_last - other.m_first + other.m_buffer;
-			other.m_first = other.m_buffer;
-			other.m_capacity = other.m_buffer + c_nbuffer;
-
-			for (pointer it = other.m_first, end = other.m_last, in = m_buffer; it != end; ++it, ++in)
-				*it = *in;
-			*other.m_last = 0;
+		{
+			const pointer tfirst = m_first, tlast = m_last, tcapacity = m_capacity;
+			m_first = other.m_first, m_last = other.m_last, m_capacity = other.m_capacity;
+			other.m_first = tfirst, other.m_last = tlast, other.m_capacity = tcapacity;
 		}
 
+		for (size_t i = 0; i < c_nbuffer; ++i) {
+			const char temp = m_buffer[i];
+			m_buffer[i] = other.m_buffer[i];
+			other.m_buffer[i] = temp;
+		}
 		if (m_first == other.m_buffer) {
-			m_last = m_last - m_first + m_buffer;
+			ptrdiff_t len = m_last - m_first;
 			m_first = m_buffer;
+			m_last = m_buffer + len;
 			m_capacity = m_buffer + c_nbuffer;
-
-			for (pointer it = m_first, end = m_last, in = tbuffer; it != end; ++it, ++in)
-				*it = *in;
-			*m_last = 0;
+		}
+		if (other.m_first == m_buffer) {
+			ptrdiff_t len = other.m_last - other.m_first;
+			other.m_first = other.m_buffer;
+			other.m_last = other.m_buffer + len;
+			other.m_capacity = other.m_buffer + c_nbuffer;
 		}
 	}
 

include/TINYSTL/string_view.h

@@ -103,7 +103,7 @@ namespace tinystl {
 	}
 
 	constexpr bool string_view::empty() const {
-    	return 0 == m_size;
+		return 0 == m_size;
 	}
 
 	constexpr string_view::iterator string_view::begin() const {

include/TINYSTL/traits.h

@@ -95,6 +95,31 @@ namespace tinystl {
 	struct remove_reference<T&&> {
 		typedef T type;
 	};
+
+	template<typename T>
+	struct remove_const {
+		typedef T type;
+	};
+
+	template<typename T>
+	struct remove_const<const T> {
+		typedef T type;
+	};
+
+	template<typename T>
+	struct remove_const<const T&> {
+		typedef T& type;
+	};
+
+	template<typename T>
+	struct remove_const<const T&&> {
+		typedef T&& type;
+	};
+
+	template<typename T>
+	struct remove_const_reference {
+		typedef typename remove_reference<typename remove_const<T>::type>::type type;
+	};
 }
 
 #endif

include/TINYSTL/unordered_map.h

@@ -95,11 +95,13 @@ namespace tinystl {
 		buffer_init<pointer, Alloc>(&m_buckets);
 		buffer_resize<pointer, Alloc>(&m_buckets, nbuckets, 0);
 
-		for (pointer it = *other.m_buckets.first; it; it = it->next) {
-			unordered_hash_node<Key, Value>* newnode = new(placeholder(), Alloc::static_allocate(sizeof(unordered_hash_node<Key, Value>))) unordered_hash_node<Key, Value>(it->first, it->second);
-			newnode->next = newnode->prev = 0;
+		if (other.m_buckets.first) {
+			for (pointer it = *other.m_buckets.first; it; it = it->next) {
+				unordered_hash_node<Key, Value>* newnode = new(placeholder(), Alloc::static_allocate(sizeof(unordered_hash_node<Key, Value>))) unordered_hash_node<Key, Value>(it->first, it->second);
+				newnode->next = newnode->prev = 0;
 
-			unordered_hash_node_insert(newnode, hash(it->first), m_buckets.first, nbuckets - 1);
+				unordered_hash_node_insert(newnode, hash(it->first), m_buckets.first, nbuckets - 1);
+			}
 		}
 	}
 
@@ -133,28 +135,36 @@ namespace tinystl {
 	template<typename Key, typename Value, typename Alloc>
 	inline typename unordered_map<Key, Value, Alloc>::iterator unordered_map<Key, Value, Alloc>::begin() {
 		iterator it;
-		it.node = *m_buckets.first;
+		if (m_buckets.first) {
+			it.node = *m_buckets.first;
+		} else {
+			it.node = nullptr;
+		}
 		return it;
 	}
 
 	template<typename Key, typename Value, typename Alloc>
 	inline typename unordered_map<Key, Value, Alloc>::iterator unordered_map<Key, Value, Alloc>::end() {
 		iterator it;
-		it.node = 0;
+		it.node = nullptr;
 		return it;
 	}
 
 	template<typename Key, typename Value, typename Alloc>
 	inline typename unordered_map<Key, Value, Alloc>::const_iterator unordered_map<Key, Value, Alloc>::begin() const {
 		const_iterator cit;
-		cit.node = *m_buckets.first;
+		if (m_buckets.first) {
+			cit.node = *m_buckets.first;
+		} else {
+			cit.node = nullptr;
+		}
 		return cit;
 	}
 
 	template<typename Key, typename Value, typename Alloc>
 	inline typename unordered_map<Key, Value, Alloc>::const_iterator unordered_map<Key, Value, Alloc>::end() const {
 		const_iterator cit;
-		cit.node = 0;
+		cit.node = nullptr;
 		return cit;
 	}
 
@@ -170,13 +180,15 @@ namespace tinystl {
 
 	template<typename Key, typename Value, typename Alloc>
 	inline void unordered_map<Key, Value, Alloc>::clear() {
-		pointer it = *m_buckets.first;
-		while (it) {
-			const pointer next = it->next;
-			it->~unordered_hash_node<Key, Value>();
-			Alloc::static_deallocate(it, sizeof(unordered_hash_node<Key, Value>));
-
-			it = next;
+		if (m_buckets.first) {
+			pointer it = *m_buckets.first;
+			while (it) {
+				const pointer next = it->next;
+				it->~unordered_hash_node<Key, Value>();
+				Alloc::static_deallocate(it, sizeof(unordered_hash_node<Key, Value>));
+
+				it = next;
+			}
 		}
 
 		m_buckets.last = m_buckets.first;
@@ -200,6 +212,7 @@ namespace tinystl {
 
 	template<typename Key, typename Value, typename Alloc>
 	inline void unordered_map<Key, Value, Alloc>::rehash(size_t nbuckets) {
+		if (!m_buckets.first) return;
 		if (m_size + 1 > 4 * nbuckets) {
 			pointer root = *m_buckets.first;
 
@@ -210,7 +223,7 @@ namespace tinystl {
 
 			while (root) {
 				const pointer next = root->next;
-				root->next = root->prev = 0;
+				root->next = root->prev = nullptr;
 				unordered_hash_node_insert(root, hash(root->first), buckets, newnbuckets);
 				root = next;
 			}
@@ -223,11 +236,11 @@ namespace tinystl {
 		result.second = false;
 
 		result.first = find(p.first);
-		if (result.first.node != 0)
+		if (result.first.node != nullptr)
 			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;
+		newnode->next = newnode->prev = nullptr;
 
 		if(!m_buckets.first) buffer_resize<pointer, Alloc>(&m_buckets, 9, 0);
 		const size_t nbuckets = (size_t)(m_buckets.last - m_buckets.first);
@@ -247,7 +260,7 @@ namespace tinystl {
 		result.second = false;
 
 		result.first = find(p.first);
-		if (result.first.node != 0)
+		if (result.first.node != nullptr)
 			return result;
 
 		const size_t keyhash = hash(p.first);