gsoap generate eml23__PositiveLongand eml23__NonNegativeLong as uint64_t

Also fix some conversion warnings
Support for multirealization indices of RESQML2.2 property

Author: philippeVerney

CMakeLists.txt

@@ -12,8 +12,8 @@ set (FESAPI_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})
 
 # version mechanism
 set (Fesapi_VERSION_MAJOR 2)
-set (Fesapi_VERSION_MINOR 14)
-set (Fesapi_VERSION_PATCH 1)
+set (Fesapi_VERSION_MINOR 15)
+set (Fesapi_VERSION_PATCH 0)
 set (Fesapi_VERSION_TWEAK 0)
 
 set (Fesapi_VERSION ${Fesapi_VERSION_MAJOR}.${Fesapi_VERSION_MINOR}.${Fesapi_VERSION_PATCH}.${Fesapi_VERSION_TWEAK})

src/CMakeLists.txt

@@ -191,6 +191,12 @@ list(APPEND ALL_SOURCES_AND_HEADERS
 )
 
 target_sources(${CPP_LIBRARY_NAME} PRIVATE ${ALL_SOURCES_AND_HEADERS})
+# Disable warnings on gsoap which we do not control
+if (WIN32)
+	set_source_files_properties(${FESAPI_PROXIES_SOURCES} PROPERTIES COMPILE_OPTIONS "/W0")
+else()
+	set_source_files_properties(${FESAPI_PROXIES_SOURCES} PROPERTIES COMPILE_OPTIONS "-w")
+endif()
 
 target_include_directories(${CPP_LIBRARY_NAME} SYSTEM PRIVATE ${MINIZIP_INCLUDE_DIR})
 

src/common/AbstractObject.cpp

@@ -411,7 +411,7 @@ namespace COMMON_NS
 		 *
 		 * @returns	The gSOAP type.
 		 */
-		int getGsoapType() const;
+		long getGsoapType() const;
 
 		/**
 		 * Creates an returns an EML2.0 data object reference which targets this data object
@@ -831,11 +831,13 @@ namespace COMMON_NS
 						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.");
+				if (rangeArray->Count > static_cast<uint64_t>((std::numeric_limits<T>::max)())) {
+					throw std::overflow_error("Please use a larger integer type");
 				}
-				for (T i = 0; i < static_cast<T>(rangeArray->Count); ++i) {
-					arrayOutput[i] = i + static_cast<T>(rangeArray->Value);
+				const T initialValue = static_cast<T>(rangeArray->Value);
+				const T count = static_cast<T>(rangeArray->Count);
+				for (T i = 0; i < count; ++i) {
+					arrayOutput[i] = i + initialValue;
 				}
 				return (std::numeric_limits<T>::max)();
 			}
@@ -871,22 +873,27 @@ namespace COMMON_NS
 					if (latticeArray->StartValue < (std::numeric_limits<T>::min)() || latticeArray->Offset[0]->Value < (std::numeric_limits<T>::min)()) {
 						throw std::underflow_error("Too low integers in XML for the C++ chosen datatype");
 					}
-					if (latticeArray->StartValue > (std::numeric_limits<T>::max)() ||
-						latticeArray->Offset[0]->Value > (std::numeric_limits<T>::max)()) {
+					if (latticeArray->StartValue > static_cast<int64_t>((std::numeric_limits<T>::max)()) ||
+						latticeArray->Offset[0]->Value > static_cast<int64_t>((std::numeric_limits<T>::max)()) ||
+						latticeArray->Offset[0]->Count > static_cast<uint64_t>((std::numeric_limits<T>::max)())) {
 						throw std::overflow_error("Too big 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<uint64_t>(latticeArray->StartValue) > (std::numeric_limits<T>::max)() ||
-						static_cast<uint64_t>(latticeArray->Offset[0]->Value) > (std::numeric_limits<T>::max)()) {
+					if (static_cast<uint64_t>(latticeArray->StartValue) > static_cast<uint64_t>((std::numeric_limits<T>::max)()) ||
+						static_cast<uint64_t>(latticeArray->Offset[0]->Value) > static_cast<uint64_t>((std::numeric_limits<T>::max)()) ||
+						latticeArray->Offset[0]->Count > static_cast<uint64_t>((std::numeric_limits<T>::max)())) {
 						throw std::overflow_error("Too big integers in XML for the C++ chosen datatype");
 					}
 				}
-				for (uint64_t i = 0; i <= latticeArray->Offset[0]->Count; ++i) {
-					arrayOutput[i] = static_cast<T>(latticeArray->StartValue) + (i * static_cast<T>(latticeArray->Offset[0]->Value));
+				const T start = static_cast<T>(latticeArray->StartValue);
+				const T step = static_cast<T>(latticeArray->Offset[0]->Value);
+				const T count = static_cast<T>(latticeArray->Offset[0]->Count);
+				for (T i = 0; i <= count; ++i) {
+					arrayOutput[i] = static_cast<T>(start + i * step);
 				}
 				return (std::numeric_limits<T>::max)();
 			}
@@ -932,12 +939,12 @@ namespace COMMON_NS
 				if (latticeArray->Offset.empty() || latticeArray->Offset.size() > 1) {
 					throw std::invalid_argument("The integer lattice array of UUID " + getUuid() + " contains zero or more than one offset.");
 				}
-				if (latticeArray->Offset[0]->Count < 0) {
-					throw std::invalid_argument("The count of the integer lattice array of UUID " + getUuid() + " is negative which is not valid.");
-				}
 
-				for (size_t i = 0; i <= static_cast<size_t>(latticeArray->Offset[0]->Count); ++i) {
-					arrayOutput[i] = latticeArray->StartValue + (i * latticeArray->Offset[0]->Value);
+				const T start = static_cast<T>(latticeArray->StartValue);
+				const T step = static_cast<T>(latticeArray->Offset[0]->Value);
+				const T count = static_cast<T>(latticeArray->Offset[0]->Count);
+				for (T i = 0; i <= count; ++i) {
+					arrayOutput[i] = static_cast<T>(start + i * step);
 				}
 				return (std::numeric_limits<T>::max)();
 			}
@@ -949,7 +956,7 @@ namespace COMMON_NS
 				std::sregex_token_iterator endToken;
 				size_t index = 0;
 				while (it != endToken) {
-					arrayOutput[index++] = std::stoll(*it++);
+					arrayOutput[index++] = static_cast<T>(std::stoll(*it++));
 				}
 				return (std::numeric_limits<T>::max)();
 			}
@@ -1076,7 +1083,7 @@ namespace COMMON_NS
 		/**
 		* Create an external data array part pointing to a named dataset in an HDF proxy
 		*/
-		gsoap_eml2_3::eml23__ExternalDataArrayPart* createExternalDataArrayPart(const std::string& datasetName, LONG64 count, EML2_NS::AbstractHdfProxy* proxy = nullptr) const;
+		gsoap_eml2_3::eml23__ExternalDataArrayPart* createExternalDataArrayPart(const std::string& datasetName, uint64_t count, EML2_NS::AbstractHdfProxy* proxy = nullptr) const;
 
 		gsoap_resqml2_0_1::resqml20__IndexableElements mapIndexableElement(gsoap_eml2_3::eml23__IndexableElement toMap) const;
 

src/common/AbstractObject.h

@@ -1476,7 +1476,7 @@ RESQML2_NS::SeismicLatticeFeature* DataObjectRepository::createSeismicLattice(co
 }
 
 RESQML2_0_1_NS::SeismicLineFeature* DataObjectRepository::createSeismicLine(const std::string & guid, const std::string & title,
-	int traceIndexIncrement, unsigned int firstTraceIndex, unsigned int traceCount)
+	int traceIndexIncrement, int firstTraceIndex, unsigned int traceCount)
 {
 	return new RESQML2_0_1_NS::SeismicLineFeature(this, guid, title, traceIndexIncrement, firstTraceIndex, traceCount);
 }

src/common/DataObjectRepository.cpp

@@ -1246,14 +1246,17 @@ namespace COMMON_NS
 		 * 								will be generated.
 		 * @param 	title			   	The title to set to the seismic line. If empty then \"unknown\"
 		 * 								title will be set.
-		 * @param 	traceIndexIncrement	The constant index increment between two consecutive traces.
-		 * @param 	firstTraceIndex	   	The index of the first trace of the seismic line.
-		 * @param 	traceCount		   	Number of traces.
+		 * @param	traceIndexIncrement	The trace index increment. The trace index increment will
+		 * 								be the difference in the trace number from abscissa i=0
+		 * 								and abscissa i=1. The increment can be a positive or
+		 * 								negative integer, but not zero.
+		 * @param 	firstTraceIndex	   	The index of the first trace beginning at abscissa i=0.
+		 * @param 	traceCount		   	The count of traces in this seismic line.
 		 *
 		 * @returns	A pointer to the new seismic line.
 		 */
 		DLL_IMPORT_OR_EXPORT RESQML2_0_1_NS::SeismicLineFeature* createSeismicLine(const std::string & guid, const std::string & title,
-			int traceIndexIncrement, unsigned int firstTraceIndex, unsigned int traceCount);
+			int traceIndexIncrement, int firstTraceIndex, unsigned int traceCount);
 
 		/**
 		 * @brief	Creates a CMP line into this repository

src/common/DataObjectRepository.h

@@ -129,19 +129,20 @@ namespace COMMON_NS
                     }
 
                     //mean
-                    valuesMean[j] += (pair.second * pair.first) / validValueCount[j];
+                    valuesMean[j] += (static_cast<double>(pair.second) * static_cast<double>(pair.first)) / static_cast<double>(validValueCount[j]);
+
                 }
-                valuesMedian[j] = (validValueCount[j] % 2 == 0) ? (median1 + median2) / 2.0 : median2;
-                modePercentage[j] = static_cast<double>(maxCount) / validValueCount[j];
+                valuesMedian[j] = (validValueCount[j] % 2 == 0) ? (static_cast<double>(median1) + static_cast<double>(median2)) / 2.0 : static_cast<double>(median2);
+                modePercentage[j] = static_cast<double>(maxCount) / static_cast<double>(validValueCount[j]);
 
 
                 // Standard Deviation
                 double variance = 0.0;
                 for (const auto& pair : mapView) {
                     double diff = static_cast<double>(pair.first) - valuesMean[j];
-                    variance += pair.second * diff * diff;
+                    variance += static_cast<double>(pair.second) * diff * diff;
                 }
-                valuesStandardDeviation[j] = std::sqrt(variance / validValueCount[j]);
+                valuesStandardDeviation[j] = std::sqrt(variance / static_cast<double>(validValueCount[j]));
             }
         }
 

src/common/NumberArrayStatistics.h

@@ -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<decltype(elementCountPerDim)::value_type>());
+	return std::accumulate(elementCountPerDim.begin(), elementCountPerDim.end(), 1u, std::multiplies<decltype(elementCountPerDim)::value_type>());
 }

src/eml2/AbstractHdfProxy.cpp

@@ -151,6 +151,7 @@ namespace EML2_NS
 		/**
 		 * Get the number of elements in each dimension of an HDF5 dataset.
 		 * uint32_t is returned instead of uint64_t cause of some SWIG usage. I cannot SWIG port std::vector<uint64_t>
+		 * EDIT : now std::vector<uint64_t> is ported by means of SWIG but such a change woudl have impact on FETPAPI as well...
 		 * @param datasetName	The absolute name of the dataset which we want to get the number of elements from.
 		 */
 		DLL_IMPORT_OR_EXPORT virtual std::vector<uint32_t> getElementCountPerDimension(const std::string & datasetName) = 0;

src/eml2/AbstractHdfProxy.h

@@ -448,37 +448,45 @@ void HdfProxy::readArrayNdOfValues(
 	if (!isOpened()) {
 		open();
 	}
+	std::string datasetName;
 
 	hsize_t hdfSlabSize = slabSize;
 	hid_t memspace = H5Screate_simple(1, &hdfSlabSize, nullptr);
 	if (memspace < 0) {
 		ssize_t size = 1 + H5Iget_name(dataset, NULL, 0);
-		char * name = (char *)malloc(size);
-		size = H5Iget_name(dataset, name, size);
-		std::string datasetName(name);
+		if (size < 0) {
+			H5Sclose(filespace);
+			H5Dclose(dataset);
+			throw invalid_argument("The name of the dataset cannot be found since its length is negative.");
+		}
+		char * name = (char *)malloc(static_cast<size_t>(size));
+		size = H5Iget_name(dataset, name, static_cast<size_t>(size));
+		datasetName = std::string(name);
 		free(name);
 		H5Sclose(filespace);
 		H5Dclose(dataset);
 		throw invalid_argument("The memory space for the slabbing of HDF5 dataset " + datasetName + " could not be created.");
 	}
 
 	hid_t readingError = H5Dread(dataset, datatype, memspace, filespace, H5P_DEFAULT, values);
-	std::string datasetName;
+	H5Sclose(memspace);
+	H5Sclose(filespace);
+
 	if (readingError < 0) {
 		ssize_t size = 1 + H5Iget_name(dataset, NULL, 0);
-		char * name = (char *)malloc(size);
-		size = H5Iget_name(dataset, name, size);
+		if (size < 0) {
+			H5Dclose(dataset);
+			throw invalid_argument("The name of the dataset cannot be found since its length is negative.");
+		}
+		char * name = (char *)malloc(static_cast<size_t>(size));
+		size = H5Iget_name(dataset, name, static_cast<size_t>(size));
 		datasetName = std::string(name);
 		free(name);
+		H5Dclose(dataset);
+		throw invalid_argument("The HDF5 dataset " + datasetName + " could not be read.");
 	}
 
-	H5Sclose(memspace);
-	H5Sclose(filespace);
 	H5Dclose(dataset);
-
-	if (readingError < 0) {
-		throw invalid_argument("The HDF5 dataset " + datasetName + " could not be read.");
-	}
 }
 
 COMMON_NS::AbstractObject::numericalDatatypeEnum HdfProxy::getNumericalDatatype(const std::string & datasetName)