Improve integer array type safety and error handling

Enhances type safety and error handling for integer array deserialization by using std::clamp and type checks for signed and unsigned types. Improves overflow and underflow detection, and ensures correct value assignment for constant, range, and lattice arrays. Also fixes a minor type issue in AbstractHdfProxy and corrects a namespace closure in AbstractValuesProperty.

Author: philippeVerney

src/common/AbstractObject.cpp

@@ -1063,8 +1063,15 @@ namespace {
 		T nullValue = (std::numeric_limits<T>::max)();
 		if (arrayInput->soap_type() == SOAP_TYPE_gsoap_resqml2_0_1_resqml20__IntegerHdf5Array) {
 			auto const* hdfArray = static_cast<gsoap_resqml2_0_1::resqml20__IntegerHdf5Array const*>(arrayInput);
-			if (hdfArray->NullValue > (std::numeric_limits<T>::min)() && hdfArray->NullValue < (std::numeric_limits<T>::max)()) {
-				nullValue = static_cast<T>(hdfArray->NullValue);
+			if constexpr (std::is_signed_v<T>) {
+				nullValue = static_cast<T>(std::clamp(hdfArray->NullValue,
+					static_cast<int64_t>((std::numeric_limits<T>::min)()), static_cast<int64_t>((std::numeric_limits<T>::max)())));
+			}
+			else {
+				if (hdfArray->NullValue > 0) {
+					nullValue = static_cast<T>(std::clamp(static_cast<uint64_t>(hdfArray->NullValue),
+						static_cast<uint64_t>(0), static_cast<uint64_t>((std::numeric_limits<T>::max)())));
+				}
 			}
 			dataset = hdfArray->Values;
 			pathInHdfFile = hdfArray->Values->PathInHdfFile;
@@ -1086,9 +1093,16 @@ namespace {
 		T nullValue = (std::numeric_limits<T>::max)();
 		if (arrayInput->soap_type() == SOAP_TYPE_gsoap_eml2_3_eml23__IntegerExternalArray) {
 			externalDataArrayParts = static_cast<gsoap_eml2_3::eml23__IntegerExternalArray const*>(arrayInput)->Values->ExternalDataArrayPart;
-			auto xmlNullValue = static_cast<gsoap_eml2_3::eml23__IntegerExternalArray const*>(arrayInput)->NullValue;
-			if (xmlNullValue > (std::numeric_limits<T>::min)() && xmlNullValue < (std::numeric_limits<T>::max)()) {
-				nullValue = static_cast<T>(xmlNullValue);
+			const int64_t xmlNullValue = static_cast<gsoap_eml2_3::eml23__IntegerExternalArray const*>(arrayInput)->NullValue;
+			if constexpr (std::is_signed_v<T>) {
+				nullValue = static_cast<T>(std::clamp(xmlNullValue,
+					static_cast<int64_t>((std::numeric_limits<T>::min)()), static_cast<int64_t>((std::numeric_limits<T>::max)())));
+			}
+			else {
+				if (xmlNullValue > 0) {
+					nullValue = static_cast<T>(std::clamp(static_cast<uint64_t>(xmlNullValue),
+						static_cast<uint64_t>(0), static_cast<uint64_t>((std::numeric_limits<T>::max)())));
+				}
 			}
 		}
 		else if (arrayInput->soap_type() == SOAP_TYPE_gsoap_eml2_3_eml23__BooleanExternalArray) {

src/common/AbstractObject.h

@@ -819,8 +819,18 @@ namespace COMMON_NS
 			case SOAP_TYPE_gsoap_resqml2_0_1_resqml20__IntegerRangeArray:
 			{
 				gsoap_resqml2_0_1::resqml20__IntegerRangeArray const* rangeArray = static_cast<gsoap_resqml2_0_1::resqml20__IntegerRangeArray const *>(arrayInput);
-				if (rangeArray->Value + rangeArray->Count > (std::numeric_limits<T>::max)()) {
-					throw std::range_error("The range integer values are superior to maximum value of read datatype.");
+				if constexpr (std::is_signed_v<T>) {
+					if (rangeArray->Value < (std::numeric_limits<T>::min)()) {
+						throw std::overflow_error("Too low integers in XML for the C++ chosen datatype");
+					}
+				}
+				else {
+					if (rangeArray->Value < 0 ) {
+						throw std::underflow_error("Cannot deal with negative values when using unsigned integer");
+					}
+				}
+				if (rangeArray->Value + rangeArray->Count > static_cast<uint64_t>((std::numeric_limits<T>::max)())) {
+					throw std::overflow_error("The range integer values are superior to maximum value of read datatype.");
 				}
 				for (T i = 0; i < static_cast<T>(rangeArray->Count); ++i) {
 					arrayOutput[i] = i + static_cast<T>(rangeArray->Value);
@@ -830,10 +840,17 @@ namespace COMMON_NS
 			case SOAP_TYPE_gsoap_resqml2_0_1_resqml20__IntegerConstantArray:
 			{
 				gsoap_resqml2_0_1::resqml20__IntegerConstantArray const* constantArray = static_cast<gsoap_resqml2_0_1::resqml20__IntegerConstantArray const*>(arrayInput);
-				if (sizeof(constantArray->Value) > sizeof(T) && constantArray->Value > (std::numeric_limits<T>::max)()) {
-					throw std::range_error("The constant integer value is superior to maximum value of read datatype.");
+				T value;
+				if constexpr (std::is_signed_v<T>) {
+					value = static_cast<T>(std::clamp(constantArray->Value,
+						static_cast<int64_t>((std::numeric_limits<T>::min)()), static_cast<int64_t>((std::numeric_limits<T>::max)())));
 				}
-				std::fill(arrayOutput, arrayOutput + constantArray->Count, static_cast<T>(constantArray->Value));
+				else {
+					value = constantArray->Value > 0
+						? static_cast<T>(std::clamp(static_cast<uint64_t>(constantArray->Value), static_cast<uint64_t>(0), static_cast<uint64_t>((std::numeric_limits<T>::max)())))
+						: (std::numeric_limits<T>::max)();
+				}
+				std::fill(arrayOutput, arrayOutput + constantArray->Count, value);
 				return (std::numeric_limits<T>::max)();
 			}
 			case SOAP_TYPE_gsoap_resqml2_0_1_resqml20__BooleanConstantArray:
@@ -848,8 +865,22 @@ namespace COMMON_NS
 				if (latticeArray->Offset.size() > 1) {
 					throw std::invalid_argument("The integer lattice array contains more than one offset.");
 				}
-				for (size_t i = 0; i <= latticeArray->Offset[0]->Count; ++i) {
-					arrayOutput[i] = latticeArray->StartValue + (i * latticeArray->Offset[0]->Value);
+				if constexpr (std::is_signed_v<T>) {
+					if (latticeArray->StartValue < (std::numeric_limits<T>::min)() || latticeArray->Offset[0]->Value < (std::numeric_limits<T>::min)()) {
+						throw std::overflow_error("Too low integers in XML for the C++ chosen datatype");
+					}
+				}
+				else {
+					if (latticeArray->StartValue < 0 || latticeArray->Offset[0]->Value < 0) {
+						throw std::underflow_error("Cannot deal with negative values when using unsigned integer");
+					}
+				}
+				if (static_cast<T>(latticeArray->StartValue) > (std::numeric_limits<T>::max)() ||
+					static_cast<T>(latticeArray->Offset[0]->Value) > (std::numeric_limits<T>::max)()) {
+					throw std::overflow_error("Too big integers in XML for the C++ chosen datatype");
+				}
+				for (auto i = 0; i <= latticeArray->Offset[0]->Count; ++i) {
+					arrayOutput[i] = static_cast<T>(latticeArray->StartValue) + (i * static_cast<T>(latticeArray->Offset[0]->Value));
 				}
 				return (std::numeric_limits<T>::max)();
 			}

src/eml2/AbstractHdfProxy.cpp

@@ -38,5 +38,5 @@ void AbstractHdfProxy::initGsoapProxy(COMMON_NS::DataObjectRepository * repo, co
 uint64_t AbstractHdfProxy::getElementCount(const std::string & datasetName)
 {
 	auto elementCountPerDim = getElementCountPerDimension(datasetName);
-	return std::accumulate(elementCountPerDim.begin(), elementCountPerDim.end(), 1, std::multiplies<uint64_t>());
+	return std::accumulate(elementCountPerDim.begin(), elementCountPerDim.end(), 1, std::multiplies<decltype(elementCountPerDim)::value_type>());
 }

src/resqml2/AbstractValuesProperty.cpp

@@ -1133,7 +1133,7 @@ namespace {
 		}
 		return xmlStats;
 	}
-};
+}
 
 gsoap_eml2_3::eml23__IntegerArrayStatistics* AbstractValuesProperty::createIntegerArrayStatisticsFrom(const COMMON_NS::NumberArrayStatistics<int8_t>& stats, size_t index) {
 	return template_createIntegerArrayStatisticsFrom(gsoapProxy2_3->soap, stats, index);