CAD DTM Rendering

include/nbl/core/containers/DoublyLinkedList.h

@@ -69,6 +69,14 @@ template<typename Value, class allocator = core::allocator<SDoublyLinkedNode<Val
 class DoublyLinkedList
 {
 public:
+	template <bool Mutable>
+	class Iterator;
+	template <bool Mutable>
+	friend class Iterator;
+
+	using iterator = Iterator<true>;
+	using const_iterator = Iterator<false>;
+
 	using allocator_t = allocator;
 	using allocator_traits_t = std::allocator_traits<allocator_t>;
 	using address_allocator_t = PoolAddressAllocator<uint32_t>;
@@ -233,16 +241,43 @@ class DoublyLinkedList
 		// Offset the array start by the storage used by the address allocator
 		m_array = reinterpret_cast<node_t*>(reinterpret_cast<uint8_t*>(m_reservedSpace) + addressAllocatorStorageSize * sizeof(node_t));
 
-		m_addressAllocator = address_allocator_t(m_reservedSpace, 0u, 0u, 1u, capacity, 1u);
 		// If allocation failed, create list with no capacity to indicate creation failed
 		m_cap = m_reservedSpace ? capacity : 0;
-		m_back = invalid_iterator;
-		m_begin = invalid_iterator;
+		m_addressAllocator = address_allocator_t(m_reservedSpace, 0u, 0u, 1u, m_cap, 1u);
 	}
 
 	DoublyLinkedList() = default;
 
-	DoublyLinkedList(const DoublyLinkedList& other) = delete;
+	// Copy Constructor
+	explicit DoublyLinkedList(const DoublyLinkedList& other) : m_dispose_f(other.m_dispose_f), m_allocator(other.m_allocator)
+	{
+		const size_t addressAllocatorStorageSize = (address_allocator_t::reserved_size(1u, other.m_cap, 1u) + sizeof(node_t) - 1) / sizeof(node_t);
+		m_currentAllocationSize = addressAllocatorStorageSize + other.m_cap;
+		m_reservedSpace = reinterpret_cast<void*>(allocator_traits_t::allocate(m_allocator, m_currentAllocationSize));
+		// If allocation failed, create a list with no capacity
+		m_cap = m_reservedSpace ? other.m_cap : 0;
+		if (!m_cap) return; // Allocation failed
+		// Offset the array start by the storage used by the address allocator
+		m_array = reinterpret_cast<node_t*>(reinterpret_cast<uint8_t*>(m_reservedSpace) + addressAllocatorStorageSize * sizeof(node_t));
+
+		if constexpr (std::is_trivially_copyable_v<Value>)
+		{
+			// Create new address allocator by copying state
+			m_addressAllocator = address_allocator_t(m_cap, other.m_addressAllocator, m_reservedSpace);
+			// Copy memory over
+			memcpy(m_array, other.m_array, m_cap * sizeof(node_t));
+			m_back = other.m_back;
+			m_begin = other.m_begin;
+		}
+		else
+		{
+			m_addressAllocator = address_allocator_t(m_reservedSpace, 0u, 0u, 1u, m_cap, 1u);
+			// Reverse iteration since we push from the front
+			for (auto it = other.crbegin(); it != other.crend(); it++)
+				pushFront(value_t(*it));
+
+		}
+	}
 
 	DoublyLinkedList& operator=(const DoublyLinkedList& other) = delete;
 
@@ -273,6 +308,16 @@ class DoublyLinkedList
 		}
 	}
 
+	// Iterator stuff
+	iterator begin();
+	iterator end();
+	const_iterator cbegin() const;
+	const_iterator cend() const;
+	std::reverse_iterator<iterator> rbegin();
+	std::reverse_iterator<iterator> rend();
+	std::reverse_iterator<const_iterator> crbegin() const;
+	std::reverse_iterator<const_iterator> crend() const;
+
 private:
 	//allocate and get the address of the next free node
 	inline uint32_t reserveAddress()
@@ -339,14 +384,130 @@ class DoublyLinkedList
 	node_t* m_array;
 
 	uint32_t m_cap;
-	uint32_t m_back;
-	uint32_t m_begin;
+	uint32_t m_back = invalid_iterator;
+	uint32_t m_begin = invalid_iterator;
 	disposal_func_t m_dispose_f;
 };
 
+// ---------------------------------------------------- ITERATOR -----------------------------------------------------------
+
+// Satifies std::bidirectional_iterator
+template<typename Value, class allocator>
+template<bool Mutable>
+class DoublyLinkedList<Value, allocator>::Iterator
+{
+	using base_iterable_t = DoublyLinkedList<Value, allocator>;
+	using iterable_t = std::conditional_t<Mutable, base_iterable_t, const base_iterable_t>;
+	friend class base_iterable_t;
+public:
+	using value_type = std::conditional_t<Mutable, Value, const Value>;
+	using pointer = value_type*;
+	using reference = value_type&;
+	using difference_type = int32_t;
+
+	Iterator() = default;
+
+	// Prefix 
+	Iterator& operator++()
+	{
+		m_current = m_iterable->get(m_current)->next;
+		return *this;
+	}
+
+	Iterator& operator--()
+	{
+		m_current = m_current != invalid_iterator ? m_iterable->get(m_current)->prev : m_iterable->m_back;
+		return *this;
+	}
+
+	// Postfix
+	Iterator operator++(int)
+	{
+		Iterator beforeIncrement = *this;
+		operator++();
+		return beforeIncrement;
+	}
+
+	Iterator operator--(int)
+	{
+		Iterator beforeDecrement = *this;
+		operator--();
+		return beforeDecrement;
+	}
 
+	// Comparison
+	bool operator==(const Iterator& rhs) const
+	{
+		return m_iterable == rhs.m_iterable && m_current == rhs.m_current;
+	}
+
+	//Deref
+	reference operator*() const
+	{
+		return m_iterable->get(m_current)->data;
+	}
+
+	pointer operator->() const
+	{
+		return & operator*();
+	}
+private:
+	Iterator(iterable_t* const iterable, uint32_t idx) : m_iterable(iterable), m_current(idx) {}
+
+	iterable_t* m_iterable;
+	uint32_t m_current;
+};
+
+template<typename Value, class allocator>
+DoublyLinkedList<Value, allocator>::iterator DoublyLinkedList<Value, allocator>::begin()
+{
+	return iterator(this, m_begin);
+}
+
+template<typename Value, class allocator>
+DoublyLinkedList<Value, allocator>::const_iterator DoublyLinkedList<Value, allocator>::cbegin() const
+{
+	return const_iterator(this, m_begin);
+}
+
+template<typename Value, class allocator>
+DoublyLinkedList<Value, allocator>::iterator DoublyLinkedList<Value, allocator>::end()
+{
+	return iterator(this, invalid_iterator);
 }
+
+template<typename Value, class allocator>
+DoublyLinkedList<Value, allocator>::const_iterator DoublyLinkedList<Value, allocator>::cend() const
+{
+	return const_iterator(this, invalid_iterator);
 }
 
+template<typename Value, class allocator>
+std::reverse_iterator<typename DoublyLinkedList<Value, allocator>::iterator> DoublyLinkedList<Value, allocator>::rbegin()
+{
+	return std::reverse_iterator<iterator>(iterator(this, invalid_iterator));
+}
+
+template<typename Value, class allocator>
+std::reverse_iterator<typename DoublyLinkedList<Value, allocator>::const_iterator> DoublyLinkedList<Value, allocator>::crbegin() const
+{
+	return std::reverse_iterator<const_iterator>(const_iterator(this, invalid_iterator));
+}
+
+template<typename Value, class allocator>
+std::reverse_iterator<typename DoublyLinkedList<Value, allocator>::iterator> DoublyLinkedList<Value, allocator>::rend()
+{
+	return std::reverse_iterator<iterator>(iterator(this, m_begin));
+}
+
+template<typename Value, class allocator>
+std::reverse_iterator<typename DoublyLinkedList<Value, allocator>::const_iterator> DoublyLinkedList<Value, allocator>::crend() const
+{
+	return std::reverse_iterator<const_iterator>(const_iterator(this, m_begin));
+}
+
+} //namespace core
+} //namespace nbl
+
 
 #endif

include/nbl/core/containers/LRUCache.h

@@ -38,6 +38,8 @@ class LRUCacheBase
 		LRUCacheBase(const uint32_t capacity, MapHash&& _hash, MapEquals&& _equals, disposal_func_t&& df) : m_list(capacity, std::move(df)), m_hash(std::move(_hash)), m_equals(std::move(_equals)), searchedKey(nullptr)
 		{ }
 
+		LRUCacheBase(const LRUCacheBase& other) : m_list(other.m_list), m_hash(other.m_hash), m_equals(other.m_equals), searchedKey(nullptr) {}
+
 	public:
 		inline const Key& getReference(const uint32_t nodeAddr) const
 		{
@@ -221,14 +223,27 @@ class [[deprecated]] LRUCache : protected impl::LRUCacheBase<Key,Value,MapHash,M
 	unordered_set<uint32_t,WrapHash,WrapEquals> m_shortcut_map;
 };
 
+namespace impl
+{
+	template<typename EvictionCallback, typename Value>
+	concept LRUCacheValueEvictionCallback = std::invocable<EvictionCallback, const Value&>;
+
+	template<typename EvictionCallback, typename Key, typename Value>
+	concept LRUCacheKeyValueEvictionCallback = std::invocable<EvictionCallback, const Key&, const Value&>;
+
+	template<typename EvictionCallback, typename Key, typename Value>
+	concept LRUCacheInsertEvictionCallback =    LRUCacheValueEvictionCallback<EvictionCallback, Value>
+									         || LRUCacheKeyValueEvictionCallback<EvictionCallback, Key, Value>;
+} //namespace impl
+
 // Key-Value Least Recently Used cache
 // Capacity can be increased at user's will
 // When the cache is full inserting will remove the least used entry
 template<typename Key, typename Value, typename MapHash = std::hash<Key>, typename MapEquals = std::equal_to<Key> >
 class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapEquals, DoublyLinkedList<std::pair<Key, Value> > >, public core::Unmovable, public core::Uncopyable
 {
 	// typedefs
-	using list_t = DoublyLinkedList<std::pair<Key, Value> >;
+	using list_t = DoublyLinkedList<std::pair<Key, Value>>;
 	using base_t = impl::LRUCacheBase<Key, Value, MapHash, MapEquals, list_t>;
 	using this_t = ResizableLRUCache<Key, Value, MapHash, MapEquals>;
 
@@ -277,6 +292,10 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 	}
 
 public:
+	// Keep it simple
+	using iterator = typename list_t::iterator;
+	using const_iterator = typename list_t::const_iterator;
+
 	using disposal_func_t = typename base_t::disposal_func_t;
 	using assoc_t = typename base_t::list_value_t;
 
@@ -289,6 +308,15 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 	}
 	ResizableLRUCache() = delete;
 
+	// It's not possible to copy the unordered_set memory-wise and just change hashing and KeyEquals functions unfortunately
+	// (in the general case that wouldn't make sense but it does here due to the way the wrappers work)
+	// Anyway, we must iterate over the old cache and copy the map over
+	explicit ResizableLRUCache(const ResizableLRUCache& other) : base_t(other), m_capacity(other.m_capacity),
+		m_shortcut_map(other.m_shortcut_map.cbegin(), other.m_shortcut_map.cend(), other.m_capacity >> 2, WrapHash{this}, WrapEquals{this})
+	{
+		m_shortcut_map.reserve(m_capacity);
+	}
+
 	inline void print(core::smart_refctd_ptr<system::ILogger> logger)
 	{
 		logger->log("Printing LRU cache contents");
@@ -323,7 +351,7 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 		return stringStream.str();
 	}
 
-	template<typename K, typename V, std::invocable<const Value&> EvictionCallback> requires std::is_constructible_v<Value, V> // && (std::is_same_v<Value,V> || std::is_assignable_v<Value,V>) // is_assignable_v<int, int&> returns false :(
+	template<typename K, typename V, typename EvictionCallback> requires std::is_constructible_v<Value, V> && impl::LRUCacheInsertEvictionCallback<EvictionCallback, Key, Value>// && (std::is_same_v<Value,V> || std::is_assignable_v<Value,V>) // is_assignable_v<int, int&> returns false :(
 	inline Value* insert(K&& k, V&& v, EvictionCallback&& evictCallback)
 	{
 		bool success;
@@ -336,10 +364,18 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 		}
 		else
 		{
-			const bool overflow = m_shortcut_map.size() >= base_t::m_list.getCapacity();
+			const bool overflow = size() >= base_t::m_list.getCapacity();
 			if (overflow)
 			{
-				evictCallback(base_t::m_list.getBack()->data.second);
+				if constexpr (impl::LRUCacheValueEvictionCallback<EvictionCallback, Value>)
+				{
+					evictCallback(base_t::m_list.getBack()->data.second);
+				}
+				// LRUCacheKeyValueEvictionCallback
+				else
+				{
+					evictCallback(base_t::m_list.getBack()->data.first, base_t::m_list.getBack()->data.second);
+				}
 				m_shortcut_map.erase(base_t::m_list.getLastAddress());
 				base_t::m_list.popBack();
 			}
@@ -389,7 +425,7 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 			return nullptr;
 	}
 
-	//remove element at key if present
+	// remove element at key if present
 	inline void erase(const Key& key)
 	{
 		bool success;
@@ -400,6 +436,20 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 			m_shortcut_map.erase(iterator);
 		}
 	}
+
+	// returns key for least recently used
+	// use in evictin callback to know which Key is being evicted
+	inline const Key* get_least_recently_used() const
+	{
+		if (size() > 0)
+			return &base_t::m_list.getBack()->data.first;
+		else
+			return nullptr;
+	}
+
+	inline size_t size() const { return m_shortcut_map.size(); }
+
+	inline bool empty() const { return size() <= 0ull;  }
 
 	/**
 	* @brief Resizes the cache by extending its capacity so it can hold more elements. Returns a bool indicating if capacity was indeed increased.
@@ -427,6 +477,17 @@ class ResizableLRUCache : protected impl::LRUCacheBase<Key, Value, MapHash, MapE
 		m_shortcut_map.erase(mapBegin, mapEnd);
 	}
 
+	// Iterator stuff
+	// Normal iterator order is MRU -> LRU
+	iterator begin() { return base_t::m_list.begin(); }
+	iterator end() { return base_t::m_list.end(); }
+	const_iterator cbegin() const { return base_t::m_list.cbegin(); }
+	const_iterator cend() const { return base_t::m_list.cend(); }
+	std::reverse_iterator<iterator> rbegin() { return base_t::m_list.rbegin(); }
+	std::reverse_iterator<iterator> rend() { return base_t::m_list.rend(); }
+	std::reverse_iterator<const_iterator> crbegin() const { return base_t::m_list.crbegin(); }
+	std::reverse_iterator<const_iterator> crend() const { return base_t::m_list.crend(); }
+
 protected:
 	unordered_set<uint32_t, WrapHash, WrapEquals> m_shortcut_map;
 	uint32_t m_capacity;