Add a few attributes to ItemValue and precise error messages

src/mesh/ItemArray.hpp

@@ -43,7 +43,7 @@ class ItemArray
   friend ItemArray<std::remove_const_t<DataType>, item_type, ConnectivityWeakPtr>;
 
  public:
-  friend PUGS_INLINE ItemArray<std::remove_const_t<DataType>, item_type, ConnectivityPtr>
+  [[nodiscard]] friend PUGS_INLINE ItemArray<std::remove_const_t<DataType>, item_type, ConnectivityPtr>
   copy(const ItemArray<DataType, item_type, ConnectivityPtr>& source)
   {
     ItemArray<std::remove_const_t<DataType>, item_type, ConnectivityPtr> image;
@@ -62,19 +62,18 @@ class ItemArray
   copy_to(const ItemArray<DataType, item_type, ConnectivityPtr>& source,
           const ItemArray<std::remove_const_t<DataType>, item_type, ConnectivityPtr2>& destination)
   {
-    Assert(destination.connectivity_ptr() == source.connectivity_ptr());
+    Assert(destination.connectivity_ptr() == source.connectivity_ptr(), "different connectivities");
+    Assert(source.sizeOfArrays() == destination.sizeOfArrays(), "incompatible size of arrays")
       copy_to(source.m_values, destination.m_values);
   }
 
-  PUGS_INLINE
-  bool
+  [[nodiscard]] PUGS_INLINE bool
   isBuilt() const noexcept
   {
     return m_connectivity_ptr.use_count() != 0;
   }
 
-  PUGS_INLINE
-  std::shared_ptr<const IConnectivity>
+  [[nodiscard]] PUGS_INLINE std::shared_ptr<const IConnectivity>
   connectivity_ptr() const noexcept
   {
     if constexpr (std::is_same_v<ConnectivityPtr, ConnectivitySharedPtr>) {
@@ -93,27 +92,26 @@ class ItemArray
   }
 
   template <ItemType item_t>
-  PUGS_INLINE typename Table<DataType>::UnsafeRowView
+  [[nodiscard]] PUGS_INLINE typename Table<DataType>::UnsafeRowView
   operator[](const ItemIdT<item_t>& item_id) const noexcept(NO_ASSERT)
   {
     static_assert(item_t == item_type, "invalid ItemId type");
-    Assert(this->isBuilt());
+    Assert(this->isBuilt(), "ItemArray is not built");
+    Assert(item_id < this->numberOfItems(), "invalid item_id");
     return m_values[item_id];
   }
 
-  PUGS_INLINE
-  size_t
+  [[nodiscard]] PUGS_INLINE size_t
   numberOfItems() const noexcept(NO_ASSERT)
   {
-    Assert(this->isBuilt());
+    Assert(this->isBuilt(), "ItemArray is not built");
     return m_values.numberOfRows();
   }
 
-  PUGS_INLINE
-  size_t
+  [[nodiscard]] PUGS_INLINE size_t
   sizeOfArrays() const
   {
-    Assert(this->isBuilt());
+    Assert(this->isBuilt(), "ItemArray is not built");
     return m_values.numberOfColumns();
   }
 
@@ -169,7 +167,7 @@ class ItemArray
   ItemArray(const IConnectivity& connectivity, const Table<DataType>& table) noexcept(NO_ASSERT)
     : m_connectivity_ptr{connectivity.shared_ptr()}, m_values{table}
   {
-    Assert(connectivity.numberOf<item_type>() == table.numberOfRows(), "Invalid table, wrong number of rows");
+    Assert(connectivity.numberOf<item_type>() == table.numberOfRows(), "invalid table, wrong number of rows");
   }
 
   PUGS_INLINE

tests/test_ItemArray.cpp

@@ -297,16 +297,16 @@ TEST_CASE("ItemArray", "[mesh]")
     SECTION("checking for build ItemArray")
     {
       CellArray<int> cell_array;
-      REQUIRE_THROWS_AS(cell_array[CellId{0}], AssertError);
+      REQUIRE_THROWS_WITH(cell_array[CellId{0}], "ItemArray is not built");
 
       FaceArray<int> face_array;
-      REQUIRE_THROWS_AS(face_array[FaceId{0}], AssertError);
+      REQUIRE_THROWS_WITH(face_array[FaceId{0}], "ItemArray is not built");
 
       EdgeArray<int> edge_array;
-      REQUIRE_THROWS_AS(edge_array[EdgeId{0}], AssertError);
+      REQUIRE_THROWS_WITH(edge_array[EdgeId{0}], "ItemArray is not built");
 
       NodeArray<int> node_array;
-      REQUIRE_THROWS_AS(node_array[NodeId{0}], AssertError);
+      REQUIRE_THROWS_WITH(node_array[NodeId{0}], "ItemArray is not built");
     }
 
     SECTION("checking for bounds violation")
@@ -322,19 +322,19 @@ TEST_CASE("ItemArray", "[mesh]")
 
           CellArray<int> cell_array{connectivity, 1};
           CellId invalid_cell_id = connectivity.numberOfCells();
-          REQUIRE_THROWS_AS(cell_array[invalid_cell_id], AssertError);
+          REQUIRE_THROWS_WITH(cell_array[invalid_cell_id], "invalid item_id");
 
           FaceArray<int> face_array{connectivity, 2};
           FaceId invalid_face_id = connectivity.numberOfFaces();
-          REQUIRE_THROWS_AS(face_array[invalid_face_id], AssertError);
+          REQUIRE_THROWS_WITH(face_array[invalid_face_id], "invalid item_id");
 
           EdgeArray<int> edge_array{connectivity, 1};
           EdgeId invalid_edge_id = connectivity.numberOfEdges();
-          REQUIRE_THROWS_AS(edge_array[invalid_edge_id], AssertError);
+          REQUIRE_THROWS_WITH(edge_array[invalid_edge_id], "invalid item_id");
 
           NodeArray<int> node_array{connectivity, 0};
           NodeId invalid_node_id = connectivity.numberOfNodes();
-          REQUIRE_THROWS_AS(node_array[invalid_node_id], AssertError);
+          REQUIRE_THROWS_WITH(node_array[invalid_node_id], "invalid item_id");
         }
       }
     }
@@ -351,7 +351,39 @@ TEST_CASE("ItemArray", "[mesh]")
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
           Table<size_t> values{connectivity.numberOfCells() + 3, 3};
-          REQUIRE_THROWS_WITH(CellArray<size_t>(connectivity, values), "Invalid table, wrong number of rows");
+          REQUIRE_THROWS_WITH(CellArray<size_t>(connectivity, values), "invalid table, wrong number of rows");
+        }
+      }
+    }
+
+    SECTION("invalid copy_to")
+    {
+      std::array mesh_list = MeshDataBaseForTests::get().all2DMeshes();
+
+      for (auto named_mesh : mesh_list) {
+        SECTION(named_mesh.name())
+        {
+          auto mesh_2d = named_mesh.mesh();
+
+          const Connectivity<2>& connectivity_2d = mesh_2d->connectivity();
+
+          std::array mesh_list = MeshDataBaseForTests::get().all3DMeshes();
+
+          for (auto named_mesh : mesh_list) {
+            SECTION(named_mesh.name())
+            {
+              auto mesh_3d = named_mesh.mesh();
+
+              const Connectivity<3>& connectivity_3d = mesh_3d->connectivity();
+
+              CellArray<int> cell_2d_array{connectivity_2d, 3};
+              CellArray<int> cell_3d_array{connectivity_3d, 3};
+              REQUIRE_THROWS_WITH(copy_to(cell_2d_array, cell_3d_array), "different connectivities");
+
+              CellArray<int> cell_2d_array2{connectivity_2d, 2};
+              REQUIRE_THROWS_WITH(copy_to(cell_2d_array, cell_2d_array2), "incompatible size of arrays");
+            }
+          }
         }
       }
     }