Skip to content

Commit 4e48dca

Browse files
philippeVerneyphilippeVerney
committed
Fix some numerical datatype conversion warnings
1 parent b1f0b13 commit 4e48dca

2 files changed

Lines changed: 85 additions & 59 deletions

File tree

‎src/etp/fesapi/FesapiHdfProxy.h‎

Lines changed: 15 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -509,16 +509,17 @@ namespace ETP_NS
509509
{
510510
// First get metadata about the data array
511511
const Energistics::Etp::v12::Datatypes::DataArrayTypes::DataArrayMetadata daMetadata = getDataArrayMetadata(datasetName);
512-
const size_t valueCount = std::accumulate(daMetadata.dimensions.begin(), daMetadata.dimensions.end(), 1, std::multiplies<int64_t>());
512+
const size_t valueCount = std::accumulate(daMetadata.dimensions.begin(), daMetadata.dimensions.end(),
513+
size_t{1}, [](size_t a, int64_t b) { return a * static_cast<size_t>(b); });
513514

514515
size_t valueSize = 1;
515516
switch (daMetadata.transportArrayType) {
516517
case Energistics::Etp::v12::Datatypes::AnyArrayType::bytes:
517518
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfBoolean: break;
518-
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfInt: valueSize = 6; break; // 25% more because of zig zag encoding worst case scenario
519-
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfFloat: valueSize = 4; break;
520-
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfLong: valueSize = 10; break; // 25% more because of zig zag encoding worst case scenario
521-
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfDouble: valueSize = 8; break;
519+
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfInt: valueSize = 6ull; break; // 25% more because of zig zag encoding worst case scenario
520+
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfFloat: valueSize = 4ull; break;
521+
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfLong: valueSize = 10ull; break; // 25% more because of zig zag encoding worst case scenario
522+
case Energistics::Etp::v12::Datatypes::AnyArrayType::arrayOfDouble: valueSize = 8ull; break;
522523
default: throw std::logic_error("Array of strings are not implemented yet");
523524
}
524525
const size_t wholeSize = valueCount * valueSize;
@@ -543,10 +544,10 @@ namespace ETP_NS
543544

544545
// Compute the dimensions of the subArrays to get
545546
size_t subArrayValueCount = 1;
546-
for (int64_t dimIndex = daMetadata.dimensions.size() - 1; dimIndex >= 0; --dimIndex) {
547-
int64_t maxCountOnDim = daMetadata.preferredSubarrayDimensions.empty()
548-
? daMetadata.dimensions[dimIndex]
549-
: daMetadata.preferredSubarrayDimensions[dimIndex];
547+
for (auto it = daMetadata.dimensions.rbegin(); it != daMetadata.dimensions.rend(); ++it) {
548+
const size_t dimIndex = static_cast<size_t>(std::distance(daMetadata.dimensions.begin(), it.base()) - 1);
549+
const int64_t maxCountOnDim = daMetadata.preferredSubarrayDimensions.empty()
550+
? *it : daMetadata.preferredSubarrayDimensions[dimIndex];
550551
subArrayValueCount *= maxCountOnDim;
551552
int64_t allowedCountOnDim = maxCountOnDim;
552553
while (subArrayValueCount * valueSize + (subArrayValueCount + 1) * 8 > maxAllowedDataArraySize) {
@@ -575,11 +576,12 @@ namespace ETP_NS
575576
// next sub array to get
576577
++subArrayIndex;
577578
hasParsedAllArray = true;
578-
for (int64_t dimIndex = daMetadata.dimensions.size() - 1; dimIndex >= 0; --dimIndex) {
579-
if (starts[dimIndex] + currentCounts[dimIndex] < daMetadata.dimensions[dimIndex]) {
579+
for (auto it = daMetadata.dimensions.rbegin(); it != daMetadata.dimensions.rend(); ++it) {
580+
const size_t dimIndex = static_cast<size_t>(std::distance(daMetadata.dimensions.begin(), it.base()) - 1);
581+
if (starts[dimIndex] + currentCounts[dimIndex] < *it) {
580582
starts[dimIndex] += currentCounts[dimIndex];
581-
if (starts[dimIndex] + currentCounts[dimIndex] > daMetadata.dimensions[dimIndex]) {
582-
currentCounts[dimIndex] = daMetadata.dimensions[dimIndex] - starts[dimIndex];
583+
if (starts[dimIndex] + currentCounts[dimIndex] > *it) {
584+
currentCounts[dimIndex] = *it - starts[dimIndex];
583585
}
584586

585587
for (size_t dimIndex2 = dimIndex + 1; dimIndex2 < daMetadata.dimensions.size(); ++dimIndex2) {

‎src/etp/protocolHandlers/GetFullDataArrayHandlers.h‎

Lines changed: 70 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -85,33 +85,43 @@ namespace ETP_NS
8585
auto dataArray = msg.dataArrays.begin()->second;
8686
if (dataArray.data.item.idx() == 0) {
8787
const Energistics::Etp::v12::Datatypes::ArrayOfBoolean& avroArray = dataArray.data.item.get_ArrayOfBoolean();
88-
for (size_t i = 0; i < avroArray.values.size(); ++i) {
89-
values[i] = avroArray.values[i];
90-
}
88+
std::transform(
89+
avroArray.values.begin(), avroArray.values.end(),
90+
values,
91+
[](const auto& x) { return static_cast<T>(x); }
92+
);
9193
}
9294
else if (dataArray.data.item.idx() == 1) {
9395
const Energistics::Etp::v12::Datatypes::ArrayOfInt& avroArray = dataArray.data.item.get_ArrayOfInt();
94-
for (size_t i = 0; i < avroArray.values.size(); ++i) {
95-
values[i] = avroArray.values[i];
96-
}
96+
std::transform(
97+
avroArray.values.begin(), avroArray.values.end(),
98+
values,
99+
[](const auto& x) { return static_cast<T>(x); }
100+
);
97101
}
98102
else if (dataArray.data.item.idx() == 2) {
99103
const Energistics::Etp::v12::Datatypes::ArrayOfLong& avroArray = dataArray.data.item.get_ArrayOfLong();
100-
for (size_t i = 0; i < avroArray.values.size(); ++i) {
101-
values[i] = avroArray.values[i];
102-
}
104+
std::transform(
105+
avroArray.values.begin(), avroArray.values.end(),
106+
values,
107+
[](const auto& x) { return static_cast<T>(x); }
108+
);
103109
}
104110
else if (dataArray.data.item.idx() == 3) {
105111
const Energistics::Etp::v12::Datatypes::ArrayOfFloat& avroArray = dataArray.data.item.get_ArrayOfFloat();
106-
for (size_t i = 0; i < avroArray.values.size(); ++i) {
107-
values[i] = avroArray.values[i];
108-
}
112+
std::transform(
113+
avroArray.values.begin(), avroArray.values.end(),
114+
values,
115+
[](const auto& x) { return static_cast<T>(x); }
116+
);
109117
}
110118
else if (dataArray.data.item.idx() == 4) {
111119
const Energistics::Etp::v12::Datatypes::ArrayOfDouble& avroArray = dataArray.data.item.get_ArrayOfDouble();
112-
for (size_t i = 0; i < avroArray.values.size(); ++i) {
113-
values[i] = avroArray.values[i];
114-
}
120+
std::transform(
121+
avroArray.values.begin(), avroArray.values.end(),
122+
values,
123+
[](const auto& x) { return static_cast<T>(x); }
124+
);
115125
}
116126
/*
117127
else if (dataArray.data.item.idx() == 5) {
@@ -123,9 +133,11 @@ namespace ETP_NS
123133
*/
124134
else if (dataArray.data.item.idx() == 6) {
125135
const std::string& avroValues = dataArray.data.item.get_bytes();
126-
for (size_t i = 0; i < avroValues.size(); ++i) {
127-
values[i] = avroValues[i];
128-
}
136+
std::transform(
137+
avroValues.begin(), avroValues.end(),
138+
values,
139+
[](const auto& x) { return static_cast<T>(x); }
140+
);
129141
}
130142
}
131143
else {
@@ -142,54 +154,63 @@ namespace ETP_NS
142154
}
143155

144156
auto dataArray = receivedKeyValue.second;
145-
size_t dataArrayValueCount = iterator->second.counts[0];
146-
for (size_t dimIndex = 1; dimIndex < iterator->second.counts.size(); ++dimIndex) {
147-
dataArrayValueCount *= iterator->second.counts[dimIndex];
148-
}
157+
int64_t dataArrayValueCount = std::accumulate(iterator->second.counts.begin(), iterator->second.counts.end(), 1, std::multiplies<int64_t>());
149158
auto currentStarts = iterator->second.starts;
150159

151-
size_t subarrayOffset = 0;
160+
int64_t subarrayOffset = 0;
152161
while (subarrayOffset < dataArrayValueCount) {
153162
// Compute the offset in the receiving array
154-
size_t arrayOffset = currentStarts.back();
163+
int64_t arrayOffset = currentStarts.back();
155164
for (int64_t dimIndex = iterator->second.counts.size() - 2; dimIndex >= 0; --dimIndex) {
156-
size_t multiplier = iterator->second.counts[dimIndex + 1];
157-
for (size_t dimIndex2 = dimIndex + 2; dimIndex2 < iterator->second.counts.size(); ++dimIndex2) {
158-
multiplier *= iterator->second.counts[dimIndex2];
159-
}
165+
int64_t multiplier = std::accumulate(iterator->second.counts.begin() + dimIndex + 1, iterator->second.counts.end(), 1, std::multiplies<int64_t>());
160166
arrayOffset += currentStarts[dimIndex] * multiplier;
161167
}
162168

163169
// Copy from the ETP subarray to the receiving array
164170
if (dataArray.data.item.idx() == 0) {
165171
const Energistics::Etp::v12::Datatypes::ArrayOfBoolean& avroArray = dataArray.data.item.get_ArrayOfBoolean();
166-
for (auto i = 0; i < iterator->second.counts.back(); ++i) {
167-
values[i + arrayOffset] = avroArray.values[i + subarrayOffset];
168-
}
172+
std::transform(
173+
avroArray.values.begin() + subarrayOffset,
174+
avroArray.values.begin() + subarrayOffset + iterator->second.counts.back(),
175+
values + arrayOffset,
176+
[](const auto& x) { return static_cast<T>(x); }
177+
);
169178
}
170179
else if (dataArray.data.item.idx() == 1) {
171180
const Energistics::Etp::v12::Datatypes::ArrayOfInt& avroArray = dataArray.data.item.get_ArrayOfInt();
172-
for (auto i = 0; i < iterator->second.counts.back(); ++i) {
173-
values[i + arrayOffset] = avroArray.values[i + subarrayOffset];
174-
}
181+
std::transform(
182+
avroArray.values.begin() + subarrayOffset,
183+
avroArray.values.begin() + subarrayOffset + iterator->second.counts.back(),
184+
values + arrayOffset,
185+
[](const auto& x) { return static_cast<T>(x); }
186+
);
175187
}
176188
else if (dataArray.data.item.idx() == 2) {
177189
const Energistics::Etp::v12::Datatypes::ArrayOfLong& avroArray = dataArray.data.item.get_ArrayOfLong();
178-
for (auto i = 0; i < iterator->second.counts.back(); ++i) {
179-
values[i + arrayOffset] = avroArray.values[i + subarrayOffset];
180-
}
190+
std::transform(
191+
avroArray.values.begin() + subarrayOffset,
192+
avroArray.values.begin() + subarrayOffset + iterator->second.counts.back(),
193+
values + arrayOffset,
194+
[](const auto& x) { return static_cast<T>(x); }
195+
);
181196
}
182197
else if (dataArray.data.item.idx() == 3) {
183198
const Energistics::Etp::v12::Datatypes::ArrayOfFloat& avroArray = dataArray.data.item.get_ArrayOfFloat();
184-
for (auto i = 0; i < iterator->second.counts.back(); ++i) {
185-
values[i + arrayOffset] = avroArray.values[i + subarrayOffset];
186-
}
199+
std::transform(
200+
avroArray.values.begin() + subarrayOffset,
201+
avroArray.values.begin() + subarrayOffset + iterator->second.counts.back(),
202+
values + arrayOffset,
203+
[](const auto& x) { return static_cast<T>(x); }
204+
);
187205
}
188206
else if (dataArray.data.item.idx() == 4) {
189207
const Energistics::Etp::v12::Datatypes::ArrayOfDouble& avroArray = dataArray.data.item.get_ArrayOfDouble();
190-
for (auto i = 0; i < iterator->second.counts.back(); ++i) {
191-
values[i + arrayOffset] = avroArray.values[i + subarrayOffset];
192-
}
208+
std::transform(
209+
avroArray.values.begin() + subarrayOffset,
210+
avroArray.values.begin() + subarrayOffset + iterator->second.counts.back(),
211+
values + arrayOffset,
212+
[](const auto& x) { return static_cast<T>(x); }
213+
);
193214
}
194215
/*
195216
else if (dataArray.data.item.idx() == 5) {
@@ -201,9 +222,12 @@ namespace ETP_NS
201222
*/
202223
else if (dataArray.data.item.idx() == 6) {
203224
const std::string& avroValues = dataArray.data.item.get_bytes();
204-
for (auto i = 0; i < iterator->second.counts.back(); ++i) {
205-
values[i + arrayOffset] = avroValues[i + subarrayOffset];
206-
}
225+
std::transform(
226+
avroValues.begin() + subarrayOffset,
227+
avroValues.begin() + subarrayOffset + iterator->second.counts.back(),
228+
values + arrayOffset,
229+
[](const auto& x) { return static_cast<T>(x); }
230+
);
207231
}
208232

209233
// Compute the new starts in the ETP subarray

0 commit comments

Comments
 (0)