Map: implement tests

CMakeLists.txt

@@ -49,4 +49,4 @@ if(${IS_TOPLEVEL_PROJECT})
     endif()
 endif()
 
-# TODO: add install target
+# TODO: add install target

include/kf/EarlyAllocator.h

@@ -24,43 +24,51 @@ namespace kf
 
         template<class Y>
         constexpr EarlyAllocator(const EarlyAllocator<Y>& other) noexcept : m_ptr(reinterpret_cast<T*>(other.m_ptr)), m_size(other.m_size)
-        {
-        }
+        { }
 
-        _CONSTEXPR20_DYNALLOC ~EarlyAllocator() = default;
-        _CONSTEXPR20_DYNALLOC EarlyAllocator& operator=(const EarlyAllocator&) = default;
+        ~EarlyAllocator() = default;
+        EarlyAllocator& operator=(const EarlyAllocator&) = default;
 
         template<POOL_TYPE poolType>
-        T* initialize(const size_t count)
+        T* initialize(const size_t count) noexcept
         {
-            assert(!m_ptr);
-            assert(!m_size);
+            if (m_ptr != nullptr || m_size != 0)
+            {
+                _Xinvalid_argument("m_ptr != nullptr || m_size != nullptr");
+            }
+
+            UNREFERENCED_PARAMETER(count);
 
             m_size = count * sizeof(T);
             m_ptr = static_cast<T*>(operator new(m_size, poolType));
 
             return m_ptr;
         }
 
-        _CONSTEXPR20_DYNALLOC void deallocate(const T* ptr, const size_t count)
+        void deallocate(const T* ptr, const size_t count) noexcept
         {
             if (ptr != m_ptr || count * sizeof(T) > m_size)
             {
                 _Xinvalid_argument("ptr != m_ptr || count * sizeof(T) > m_size");
             }
 
+            UNREFERENCED_PARAMETER(ptr);
+            UNREFERENCED_PARAMETER(count);
+
             operator delete(m_ptr);
             m_ptr = nullptr;
             m_size = 0;
         }
 
-        _NODISCARD _CONSTEXPR20_DYNALLOC T* allocate(const size_t count)
+        _NODISCARD T* allocate(const size_t count) noexcept
         {
-            if (!m_ptr || count * sizeof(T) > m_size)
+            if (m_ptr == nullptr || count * sizeof(T) > m_size)
             {
-                _Xinvalid_argument("!m_ptr || count * sizeof(T) > m_size");
+                _Xinvalid_argument("m_ptr == nullptr || count * sizeof(T) > m_size");
             }
 
+            UNREFERENCED_PARAMETER(count);
+
             return m_ptr;
         }
 

include/kf/Map.h

@@ -0,0 +1,166 @@
+#pragma once
+#include <kf/MapAllocator.h>
+#include <map>
+#include <optional>
+
+#if _ITERATOR_DEBUG_LEVEL > 0
+#error "_ITERATOR_DEBUG_LEVEL must not be greater than 0"
+#endif
+
+namespace kf
+{
+    template<typename KeyType, typename ValueType, POOL_TYPE poolType, typename LessComparer = std::less<KeyType>>
+    class Map
+    {
+    public:
+        using AllocatorType = MapAllocator<std::pair<const KeyType, ValueType>, poolType>;
+        using MapType = std::map<KeyType, ValueType, LessComparer, AllocatorType>;
+        using Iterator = MapType::iterator;
+        using ConstIterator = MapType::const_iterator;
+        using SizeType = MapType::size_type;
+
+    public:
+        Map() = default;
+
+        Map(const Map&) = delete;
+        Map& operator=(const Map&) = delete;
+
+        Map(Map&& other) = default;
+        Map& operator=(Map&& other) = default;
+
+        [[nodiscard]] NTSTATUS initialize()
+        {
+            AllocatorType allocator;
+            if (!allocator.initialize())
+            {
+                return STATUS_INSUFFICIENT_RESOURCES;
+            }
+
+            // Prepare memory for head node
+            if (!allocator.prepareMemory(kNodeSize))
+            {
+                return STATUS_INSUFFICIENT_RESOURCES;
+            }
+
+            m_internalMap = make_unique<MapType, poolType>(allocator);
+            if (!m_internalMap)
+            {
+                return STATUS_INSUFFICIENT_RESOURCES;
+            }
+
+            return STATUS_SUCCESS;
+        }
+
+        std::optional<std::reference_wrapper<ValueType>> operator[](KeyType&& key)
+        {
+            if (!m_internalMap->get_allocator().prepareMemory(kNodeSize))
+            {
+                return {};
+            }
+
+            return std::ref((*m_internalMap)[std::forward<KeyType>(key)]);
+        }
+
+        template <class... ValuesType>
+        std::optional<std::pair<Iterator, bool>> emplace(ValuesType&&... values)
+        {
+            if (!m_internalMap->get_allocator().prepareMemory(kNodeSize))
+            {
+                return {};
+            }
+
+            return m_internalMap->emplace(std::forward<ValuesType>(values)...);
+        }
+
+        [[nodiscard]] Iterator find(const KeyType& key)
+        {
+            return m_internalMap->find(key);
+        }
+
+        [[nodiscard]] ConstIterator find(const KeyType& key) const
+        {
+            return m_internalMap->find(key);
+        }
+
+#if _HAS_CXX20
+        [[nodiscard]] bool contains(const KeyType& key) const
+        {
+            return m_internalMap->contains(key);
+        }
+#endif
+
+        void clear() noexcept
+        {
+            m_internalMap->clear();
+        }
+
+        Iterator erase(ConstIterator where) noexcept
+        {
+            return m_internalMap->erase(where);
+        }
+
+        Iterator erase(ConstIterator first, ConstIterator last) noexcept
+        {
+            return m_internalMap->erase(first, last);
+        }
+
+        SizeType erase(const KeyType& key) noexcept
+        {
+            return m_internalMap->erase(key);
+        }
+
+        [[nodiscard]] Iterator begin() noexcept
+        {
+            return m_internalMap->begin();
+        }
+
+        [[nodiscard]] ConstIterator begin() const noexcept
+        {
+            return m_internalMap->begin();
+        }
+
+        [[nodiscard]] Iterator end() noexcept
+        {
+            return m_internalMap->end();
+        }
+
+        [[nodiscard]] ConstIterator end() const noexcept
+        {
+            return m_internalMap->end();
+        }
+
+        [[nodiscard]] Iterator upper_bound(const KeyType& key)
+        {
+            return m_internalMap->upper_bound(key);
+        }
+
+        [[nodiscard]] ConstIterator upper_bound(const KeyType& key) const
+        {
+            return m_internalMap->upper_bound(key);
+        }
+
+        [[nodiscard]] Iterator lower_bound(const KeyType& key)
+        {
+            return m_internalMap->lower_bound(key);
+        }
+
+        [[nodiscard]] ConstIterator lower_bound(const KeyType& key) const
+        {
+            return m_internalMap->lower_bound(key);
+        }
+
+        bool empty() const noexcept
+        {
+            return m_internalMap->empty();
+        }
+
+        SizeType size() const noexcept
+        {
+            return m_internalMap->size();
+        }
+
+    private:
+        static constexpr size_t kNodeSize = sizeof(MapType::_Alnode_traits::value_type);
+        std::unique_ptr<MapType> m_internalMap;
+    };
+}

include/kf/MapAllocator.h

@@ -0,0 +1,89 @@
+#pragma once
+#include <kf/stl/memory>
+
+namespace kf
+{
+    struct AllocatorState
+    {
+        std::unique_ptr<char[]> buffer;
+        size_t size;
+    };
+
+    template<typename T, POOL_TYPE poolType>
+    class MapAllocator
+    {
+    public:
+        using value_type = T;
+
+        MapAllocator() = default;
+
+        // Needed because allocator has extra parameter for POOL_TYPE
+        template <typename U>
+        struct rebind
+        {
+            using other = MapAllocator<U, poolType>;
+        };
+
+        friend class MapAllocator;
+
+        template<typename U>
+        MapAllocator(const MapAllocator<U, poolType>& other)
+            : m_state(other.m_state)
+        {
+        }
+
+        [[nodiscard]] bool initialize()
+        {
+            m_state = make_shared<AllocatorState, poolType>();
+            return m_state != nullptr;
+        }
+
+        T* allocate(std::size_t n)
+        {
+            if (!m_state || !m_state->buffer)
+            {
+                return nullptr;
+            }
+
+            if (m_state->size < n)
+            {
+                return nullptr;
+            }
+
+            auto buffer = reinterpret_cast<T*>(m_state->buffer.release());
+            m_state->size = 0;
+            return buffer;
+        }
+
+        void deallocate(T*, std::size_t)
+        {
+            m_state->buffer.reset();
+            m_state->size = 0;
+        }
+
+        [[nodiscard]] bool prepareMemory(std::size_t size)
+        {
+            if (!m_state)
+            {
+                return false;
+            }
+
+            if (m_state->buffer)
+            {
+                return true;
+            }
+
+            m_state->buffer.reset(new(poolType) char[size]);
+            if (!m_state->buffer)
+            {
+                return false;
+            }
+            m_state->size = size;
+
+            return true;
+        }
+
+    private:
+        std::shared_ptr<AllocatorState> m_state;
+    };
+}

include/kf/UString.h

@@ -75,6 +75,7 @@ namespace kf
 
             if (newByteLength > 0)
             {
+#pragma warning(suppress : 4996) // ExAllocatePoolWithTag is deprecated, use ExAllocatePool2
 #pragma warning(suppress: 28160) // Must succeed pool allocations are forbidden. Allocation failures cause a system crash.
                 newBuffer = ::ExAllocatePoolWithTag(poolType, newByteLength, PoolTag);
 

include/kf/stl/memory

@@ -1,6 +1,7 @@
 #pragma once
 #include <memory>
 #include <type_traits>
+#include <kf/stl/new>
 #include <kf/EarlyAllocator.h>
 
 template<typename T, POOL_TYPE PoolType, typename... TArgs>

include/kf/stl/new

@@ -3,21 +3,22 @@
 #pragma warning(push)
 #pragma warning(disable : 4595) // non-member operator new or delete functions may not be declared inline
 
-inline void* __cdecl operator new(size_t size, POOL_TYPE poolType)
+inline void* __cdecl operator new(size_t size, POOL_TYPE poolType) noexcept
 {
 #pragma warning(suppress: 28160) // Must succeed pool allocations are forbidden. Allocation failures cause a system crash.
+#pragma warning(suppress: 4996) // ExAllocatePoolWithTag is deprecated, use ExAllocatePool2
     return ::ExAllocatePoolWithTag(poolType, size ? size : 1, 'n++C');
 }
 
-inline void __cdecl operator delete(void* ptr)
+inline void __cdecl operator delete(void* ptr) noexcept
 {
     if (ptr)
     {
         ::ExFreePoolWithTag(ptr, 'n++C');
     }
 }
 
-inline void __cdecl operator delete[](void* ptr)
+inline void __cdecl operator delete[](void* ptr) noexcept
 {
     if (ptr)
     {
@@ -26,7 +27,14 @@ inline void __cdecl operator delete[](void* ptr)
 }
 
 // size-aware deallocation
-inline void __cdecl operator delete(void* ptr, size_t)
+inline void __cdecl operator delete(void* ptr, size_t) noexcept
+{
+    operator delete(ptr);
+}
+
+// To avoid warning C4291: 'void *operator new(size_t,POOL_TYPE) noexcept':
+// no matching operator delete found; memory will not be freed if initialization throws an exception
+inline void operator delete(void* ptr, POOL_TYPE) noexcept
 {
     operator delete(ptr);
 }