Merge pull request #1987 from arcaneframework/dev/gg-minor-improvement-for-array

Minor improvements for `Array` classes

Author: grospelliergilles

arccore/src/collections/arccore/collections/Array.h

@@ -1295,11 +1295,17 @@ class Array
     m_ptr[m_md->size].~T();
   }
   //! Elément d'indice \a i. Vérifie toujours les débordements
-  ConstReferenceType at(Int64 i) const
+  T& at(Int64 i)
   {
     arccoreCheckAt(i,m_md->size);
     return m_ptr[i];
   }
+  //! Elément d'indice \a i. Vérifie toujours les débordements
+  ConstReferenceType at(Int64 i) const
+  {
+    arccoreCheckAt(i, m_md->size);
+    return m_ptr[i];
+  }
   //! Positionne l'élément d'indice \a i. Vérifie toujours les débordements
   void setAt(Int64 i,ConstReferenceType value)
   {
@@ -1593,18 +1599,24 @@ class SharedArray
   inline SharedArray(const UniqueArray<T>& rhs);
 
   /*!
-   * \brief Créé un tableau de \a asize éléments avec un
-   * allocateur spécifique \a allocator.
-   *
-   * Si ArrayTraits<T>::IsPODType vaut TrueType, les éléments ne sont pas
-   * initialisés. Sinon, c'est le constructeur par défaut de T qui est utilisé.
+   * \brief Créé un tableau vide avec un allocateur spécifique \a allocator.
    *
    * \warning Using specific allocator for SharedArray is experimental
    */
   explicit SharedArray(IMemoryAllocator* allocator)
+  : SharedArray(MemoryAllocationOptions(allocator))
+  {
+  }
+
+  /*!
+   * \brief Créé un tableau vide avec un allocateur spécifique \a allocation_options.
+   *
+   * \warning Using specific allocator for SharedArray is experimental
+   */
+  explicit SharedArray(const MemoryAllocationOptions& allocation_options)
   : Array<T>()
   {
-    this->_initFromAllocator(allocator,0);
+    this->_initFromAllocator(allocation_options,0);
     this->_checkValidSharedArray();
   }
 
@@ -1614,22 +1626,28 @@ class SharedArray
    *
    * Si ArrayTraits<T>::IsPODType vaut TrueType, les éléments ne sont pas
    * initialisés. Sinon, c'est le constructeur par défaut de T qui est utilisé.
-   *
-   * \warning Using specific allocator for SharedArray is experimental
    */
   SharedArray(IMemoryAllocator* allocator,Int64 asize)
-  : Array<T>()
+  : SharedArray(MemoryAllocationOptions(allocator), asize)
   {
-    this->_initFromAllocator(allocator,asize);
-    this->_resize(asize);
-    this->_checkValidSharedArray();
   }
 
   /*!
-   * \brief Créé un tableau avec l'allocateur \a allocator en recopiant les valeurs \a rhs.
+   * \brief Créé un tableau de \a asize éléments avec un
+   * allocateur spécifique \a allocator.
    *
-   * \warning Using specific allocator for SharedArray is experimental
+   * Si ArrayTraits<T>::IsPODType vaut TrueType, les éléments ne sont pas
+   * initialisés. Sinon, c'est le constructeur par défaut de T qui est utilisé.
    */
+  SharedArray(const MemoryAllocationOptions& allocation_options, Int64 asize)
+  : Array<T>()
+  {
+    this->_initFromAllocator(allocation_options, asize);
+    this->_resize(asize);
+    this->_checkValidSharedArray();
+  }
+
+  //!Créé un tableau avec l'allocateur \a allocator en recopiant les valeurs \a rhs.
   SharedArray(IMemoryAllocator* allocator,Span<const T> rhs)
   {
     this->_initFromAllocator(allocator,0);

arccore/src/collections/tests/TestArray.cc

@@ -479,8 +479,12 @@ TEST(Array, Misc2)
     UniqueArray<Real> v;
     v.resize(3);
     v[0] = 1.2;
-    v[1] = -1.3;
+    v.at(1) = -1.3;
     v[2] = 7.6;
+    ASSERT_EQ(v[0], 1.2);
+    ASSERT_EQ(v[1], -1.3);
+    ASSERT_EQ(v.at(2), 7.6);
+
     v.add(4.3);
     for (Real x : v) {
       std::cout << " Value: " << x << '\n';
@@ -826,7 +830,7 @@ TEST(SharedArray, Allocator)
     ASSERT_EQ(a1.size(), 5);
 
     std::cout << "Array a3\n";
-    SharedArray<Int32> a3(allocator1);
+    SharedArray<Int32> a3(MemoryAllocationOptions{ allocator1 });
     a3.add(4);
     a3.add(6);
     a3.add(2);
@@ -837,19 +841,24 @@ TEST(SharedArray, Allocator)
     ASSERT_EQ(a3.constSpan(), a1.constSpan());
 
     std::cout << "Array a4\n";
-    SharedArray<Int32> a4(allocator1);
+    SharedArray<Int32> a4(allocator1, 2);
+    ASSERT_EQ(a4.size(), 2);
     a4.add(4);
     a4.add(6);
     a4.add(2);
-    ASSERT_EQ(a4.size(), 3);
+    ASSERT_EQ(a4.size(), 5);
+    ASSERT_EQ(a4[2], 4);
+    ASSERT_EQ(a4[3], 6);
+    ASSERT_EQ(a4[4], 2);
+
     a4 = a1.span();
     ASSERT_EQ(a4.allocator(), allocator1);
 
     a4 = SharedArray<Int32>(&printable_allocator2);
 
     SharedArray<Int32> array[2];
     IMemoryAllocator* allocator3 = allocator1;
-    for( Integer i=0; i<2; ++i ){
+    for (Integer i = 0; i < 2; ++i) {
       array[i] = SharedArray<Int32>(allocator3);
     }
     ASSERT_EQ(array[0].allocator(), allocator3);
@@ -1008,6 +1017,7 @@ TEST(Array, DebugInfo)
   MemoryAllocationOptions allocate_options2(&m_default_allocator, eMemoryLocationHint::None, 0);
 
   String a1_name("Array1");
+  String sa1_name("SharedArray1");
   UniqueArray<Int32> a3;
   {
     std::cout << "Array a1\n";
@@ -1019,6 +1029,17 @@ TEST(Array, DebugInfo)
     ASSERT_EQ(a1.data(), nullptr);
     ASSERT_EQ(a1.debugName(), a1_name);
 
+    std::cout << "SharedArray sa1\n";
+    SharedArray<Int32> sa1(allocate_options2);
+    sa1.setDebugName(sa1_name);
+    ASSERT_EQ(sa1.allocationOptions(), allocate_options2);
+    ASSERT_EQ(sa1.size(), 0);
+    ASSERT_EQ(sa1.capacity(), 0);
+    ASSERT_EQ(sa1.data(), nullptr);
+    ASSERT_EQ(sa1.debugName(), sa1_name);
+
+    ASSERT_EQ(a1.debugName(), a1_name);
+
     std::cout << "Array a2\n";
     UniqueArray<Int32> a2(a1);
     ASSERT_SAME_ARRAY_INFOS(a2, a1);