adding bracket operator

OpenCyphal · thirtytwobits · Jun 7, 2021 · Jan 30, 2021 · Jan 31, 2021 · Feb 7, 2021
commit 993986b8d7edb0c16a443aee21fe43072a280e1a
diff --git a/src/nunavut/lang/cpp/support/VariableLengthArray.hpp b/src/nunavut/lang/cpp/support/VariableLengthArray.hpp
@@ -45,6 +45,16 @@ class VariableLengthArray
         return data_;
     }
 
+    constexpr const T& operator[](std::size_t i) const
+    {
+        return data_[i];
+    }
+
+    constexpr T& operator[](std::size_t i)
+    {
+        return data_[i];
+    }
+
     // +----------------------------------------------------------------------+
     // | CAPACITY
     // +----------------------------------------------------------------------+
@@ -72,31 +82,34 @@ class VariableLengthArray
         const std::size_t no_shrink_capacity = (clamped_capacity > old_data_size) ? clamped_capacity : old_data_size;
         T* new_data = alloc_.allocate(no_shrink_capacity);
 
-        if (old_data_size < 0 && new_data != old_data)
+        if (new_data != nullptr)
         {
-            // The allocator returned new memory. Copy any initialized objects in the old region to the new one.
-            // Check for memory overlap.
-            const std::size_t old_data_size_bytes = (old_data_size * sizeof(T));
-            if (
-                (old_data + old_data_size_bytes < new_data)
-                    ||
-                (new_data + old_data_size_bytes < old_data)
-               )
+            if (old_data_size > 0 && new_data != old_data)
             {
-                // Initialized regions do not overlap. Use memcpy.
-                std::memcpy(new_data, old_data, old_data_size_bytes);
+                // The allocator returned new memory. Copy any initialized objects in the old region to the new one.
+                // Check for memory overlap.
+                const std::size_t old_data_size_bytes = (old_data_size * sizeof(T));
+                if (
+                    (old_data + old_data_size_bytes < new_data)
+                        ||
+                    (new_data + old_data_size_bytes < old_data)
+                )
+                {
+                    // Initialized regions do not overlap. Use memcpy.
+                    std::memcpy(new_data, old_data, old_data_size_bytes);
+                }
+                else
+                {
+                    // Initialized regions overlap. Use memmove.
+                    std::memmove(new_data, old_data, old_data_size_bytes);
+                }
             }
-            else
-            {
-                // Initialized regions overlap. Use memmove.
-                std::memmove(new_data, old_data, old_data_size_bytes);
-            }
-        }
 
-        data_ = new_data;
-        capacity_ = no_shrink_capacity;
+            data_ = new_data;
+            capacity_ = no_shrink_capacity;
+        }
 
-        return no_shrink_capacity;
+        return capacity_;
     }
 
 

diff --git a/verification/cpp/suite/test_var_len_arr.cpp b/verification/cpp/suite/test_var_len_arr.cpp
@@ -10,6 +10,9 @@
 #include <type_traits>
 #include "o1heap/o1heap.h"
 
+/**
+ * Pavel's O(1) Heap Allocator wrapped in an std::allocator concept.
+ */
 template<typename T, std::size_t SizeCount>
 class O1HeapAllocator
 {
@@ -24,25 +27,62 @@ class O1HeapAllocator
 
     T* allocate( std::size_t n )
     {
-        return reinterpret_cast<T*>(o1heapAllocate(heap_alloc_, n));
+        return reinterpret_cast<T*>(o1heapAllocate(heap_alloc_, n * sizeof(T)));
     }
 
 private:
     typename std::aligned_storage<sizeof(T), O1HEAP_ALIGNMENT>::type heap_[SizeCount];
     O1HeapInstance* heap_alloc_;
 };
 
+/**
+ * A Junky static allocator.
+ */
+template<typename T, std::size_t SizeCount>
+class JunkyStaticAllocator
+{
+public:
+    using value_type = T;
+
+    JunkyStaticAllocator()
+        : data_()
+    {
+    }
+
+    T* allocate( std::size_t n )
+    {
+        if (n < SizeCount)
+        {
+            return reinterpret_cast<T*>(&data_[0]);
+        }
+        else
+        {
+            return nullptr;
+        }
+    }
+
+private:
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type data_[SizeCount];
+};
+
+// +----------------------------------------------------------------------+
+/**
+ * Test suite for running multiple allocators against the variable length array type.
+ */
 template <typename T>
-class VariableLengthArrayTestSuite : public ::testing::Test
+class VLATestsGeneric : public ::testing::Test
 {
 };
 
-using VariableLengthArrayTestAllocators = ::testing::Types<std::allocator<int>,
+using VLATestsGenericAllocators = ::testing::Types<std::allocator<int>,
                                                            std::allocator<long long>,
-                                                           O1HeapAllocator<int, O1HEAP_ALIGNMENT * 8>>;
-TYPED_TEST_SUITE(VariableLengthArrayTestSuite, VariableLengthArrayTestAllocators,);
+                                                           O1HeapAllocator<int, O1HEAP_ALIGNMENT * 8>,
+                                                           JunkyStaticAllocator<int, 10>>;
+TYPED_TEST_SUITE(VLATestsGeneric, VLATestsGenericAllocators,);
+
 
-TYPED_TEST(VariableLengthArrayTestSuite, TestReserve)
+
+TYPED_TEST(VLATestsGeneric, TestReserve)
 {
     nunavut::support::VariableLengthArray<typename TypeParam::value_type, TypeParam, 10> subject;
     ASSERT_EQ(nullptr, subject.data());
@@ -51,7 +91,7 @@ TYPED_TEST(VariableLengthArrayTestSuite, TestReserve)
     ASSERT_EQ(10U, subject.max_size());
     ASSERT_EQ(nullptr, subject.push_back_no_alloc(1));
 
-    subject.reserve(1);
+    ASSERT_EQ(1U, subject.reserve(1));
 
     ASSERT_EQ(1U, subject.capacity());
     ASSERT_EQ(0U, subject.size());
@@ -60,3 +100,46 @@ TYPED_TEST(VariableLengthArrayTestSuite, TestReserve)
     ASSERT_EQ(*pushed, 1);
     ASSERT_EQ(1U, subject.size());
 }
+
+
+// +----------------------------------------------------------------------+
+/**
+ * Test suite for running static allocators against the variable length array type.
+ */
+template <typename T>
+class VLATestsStatic : public ::testing::Test
+{
+};
+
+using VLATestsStaticAllocators = ::testing::Types<O1HeapAllocator<int, O1HEAP_ALIGNMENT * 8>,
+                                                           JunkyStaticAllocator<int, 10>>;
+TYPED_TEST_SUITE(VLATestsStatic, VLATestsStaticAllocators,);
+
+TYPED_TEST(VLATestsStatic, TestOutOfMemory)
+{
+    nunavut::support::VariableLengthArray<typename TypeParam::value_type, TypeParam, 10> subject;
+    ASSERT_EQ(0U, subject.capacity());
+
+    std::size_t last_capacity = subject.capacity();
+    bool did_run_out_of_memory = false;
+    std::size_t ran_out_of_memory_at = 0;
+    for(std::size_t i = 1; i <= 1024; ++i)
+    {
+        if (last_capacity == subject.reserve(i))
+        {
+            did_run_out_of_memory = true;
+            ran_out_of_memory_at = i - 1;
+            break;
+        }
+        last_capacity = subject.capacity();
+        typename TypeParam::value_type* pushed = subject.push_back_no_alloc(static_cast<typename TypeParam::value_type>(i));
+        ASSERT_NE(nullptr, pushed);
+        ASSERT_EQ(static_cast<typename TypeParam::value_type>(i), *pushed);
+    }
+    ASSERT_TRUE(did_run_out_of_memory);
+    ASSERT_EQ(nullptr,subject.push_back_no_alloc(0));
+    for(std::size_t i = 0; i < ran_out_of_memory_at; ++i)
+    {
+        ASSERT_EQ(static_cast<typename TypeParam::value_type>(i+1), subject[i]);
+    }
+}