Add a few attributes to ItemValue and precise error messages

src/mesh/ItemValue.hpp

@@ -43,7 +43,7 @@ class ItemValue
   friend ItemValue<std::remove_const_t<DataType>, item_type, ConnectivityWeakPtr>;
 
  public:
-  friend PUGS_INLINE ItemValue<std::remove_const_t<DataType>, item_type, ConnectivityPtr>
+  [[nodiscard]] friend PUGS_INLINE ItemValue<std::remove_const_t<DataType>, item_type, ConnectivityPtr>
   copy(const ItemValue<DataType, item_type, ConnectivityPtr>& source)
   {
     ItemValue<std::remove_const_t<DataType>, item_type, ConnectivityPtr> image;
@@ -62,19 +62,17 @@ class ItemValue
   copy_to(const ItemValue<DataType, item_type, ConnectivityPtr>& source,
           const ItemValue<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");
     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>) {
@@ -84,11 +82,10 @@ class ItemValue
     }
   }
 
-  PUGS_INLINE
-  size_t
+  [[nodiscard]] PUGS_INLINE size_t
   numberOfItems() const noexcept(NO_ASSERT)
   {
-    Assert(this->isBuilt());
+    Assert(this->isBuilt(), "ItemValue is not built");
     return m_values.size();
   }
 
@@ -101,11 +98,12 @@ class ItemValue
   }
 
   template <ItemType item_t>
-  PUGS_INLINE DataType&
+  [[nodiscard]] PUGS_INLINE DataType&
   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(), "ItemValue is not built");
+    Assert(item_id < this->numberOfItems(), "invalid item_id");
     return m_values[item_id];
   }
 
@@ -160,7 +158,7 @@ class ItemValue
   ItemValue(const IConnectivity& connectivity, const Array<DataType>& values) noexcept(NO_ASSERT)
     : m_connectivity_ptr{connectivity.shared_ptr()}, m_values{values}
   {
-    Assert((m_values.size() == connectivity.numberOf<item_type>()), "Invalid values size");
+    Assert(m_values.size() == connectivity.numberOf<item_type>(), "invalid values size");
   }
 
   PUGS_INLINE

tests/test_ItemValue.cpp

@@ -241,16 +241,16 @@ TEST_CASE("ItemValue", "[mesh]")
     SECTION("checking for build ItemValue")
     {
       CellValue<int> cell_value;
-      REQUIRE_THROWS_AS(cell_value[CellId{0}], AssertError);
+      REQUIRE_THROWS_WITH(cell_value[CellId{0}], "ItemValue is not built");
 
       FaceValue<int> face_value;
-      REQUIRE_THROWS_AS(face_value[FaceId{0}], AssertError);
+      REQUIRE_THROWS_WITH(face_value[FaceId{0}], "ItemValue is not built");
 
       EdgeValue<int> edge_value;
-      REQUIRE_THROWS_AS(edge_value[EdgeId{0}], AssertError);
+      REQUIRE_THROWS_WITH(edge_value[EdgeId{0}], "ItemValue is not built");
 
       NodeValue<int> node_value;
-      REQUIRE_THROWS_AS(node_value[NodeId{0}], AssertError);
+      REQUIRE_THROWS_WITH(node_value[NodeId{0}], "ItemValue is not built");
     }
 
     SECTION("checking for bounds violation")
@@ -266,19 +266,19 @@ TEST_CASE("ItemValue", "[mesh]")
 
           CellValue<int> cell_value{connectivity};
           CellId invalid_cell_id = connectivity.numberOfCells();
-          REQUIRE_THROWS_AS(cell_value[invalid_cell_id], AssertError);
+          REQUIRE_THROWS_WITH(cell_value[invalid_cell_id], "invalid item_id");
 
           FaceValue<int> face_value{connectivity};
           FaceId invalid_face_id = connectivity.numberOfFaces();
-          REQUIRE_THROWS_AS(face_value[invalid_face_id], AssertError);
+          REQUIRE_THROWS_WITH(face_value[invalid_face_id], "invalid item_id");
 
           EdgeValue<int> edge_value{connectivity};
           EdgeId invalid_edge_id = connectivity.numberOfEdges();
-          REQUIRE_THROWS_AS(edge_value[invalid_edge_id], AssertError);
+          REQUIRE_THROWS_WITH(edge_value[invalid_edge_id], "invalid item_id");
 
           NodeValue<int> node_value{connectivity};
           NodeId invalid_node_id = connectivity.numberOfNodes();
-          REQUIRE_THROWS_AS(node_value[invalid_node_id], AssertError);
+          REQUIRE_THROWS_WITH(node_value[invalid_node_id], "invalid item_id");
         }
       }
     }
@@ -295,7 +295,7 @@ TEST_CASE("ItemValue", "[mesh]")
           const Connectivity<3>& connectivity = mesh_3d->connectivity();
 
           Array<size_t> values{3 + connectivity.numberOfCells()};
-          REQUIRE_THROWS_WITH(CellValue<size_t>(connectivity, values), "Invalid values size");
+          REQUIRE_THROWS_WITH(CellValue<size_t>(connectivity, values), "invalid values size");
         }
       }
     }
@@ -322,7 +322,7 @@ TEST_CASE("ItemValue", "[mesh]")
 
               CellValue<int> cell_2d_value{connectivity_2d};
               CellValue<int> cell_3d_value{connectivity_3d};
-              REQUIRE_THROWS_AS(copy_to(cell_2d_value, cell_3d_value), AssertError);
+              REQUIRE_THROWS_WITH(copy_to(cell_2d_value, cell_3d_value), "different connectivities");
             }
           }
         }