Skip to content

Commit a8f5880

Browse files
paleolimbotpaleolimbot
committed
compiler warnings
1 parent 31379e8 commit a8f5880

File tree

9 files changed

+91
-84
lines changed

9 files changed

+91
-84
lines changed

‎dev/benchmarks/c/array_benchmark.cc

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -231,7 +231,7 @@ static void BenchmarkArrayViewGetString(benchmark::State& state) {
231231

232232
int64_t n_alphabets = n_values / alphabet.size() + 1;
233233
std::vector<char> data(alphabet.size() * n_alphabets);
234-
for (int64_t data_pos = 0; data_pos < data.size(); data_pos += alphabet.size()) {
234+
for (size_t data_pos = 0; data_pos < data.size(); data_pos += alphabet.size()) {
235235
memcpy(data.data() + data_pos, alphabet.data(), alphabet.size());
236236
}
237237

@@ -262,7 +262,7 @@ static ArrowErrorCode CreateAndAppendToArrayInt(ArrowArray* array,
262262
NANOARROW_RETURN_NOT_OK(ArrowArrayInitFromType(array, type));
263263
NANOARROW_RETURN_NOT_OK(ArrowArrayStartAppending(array));
264264

265-
for (int64_t i = 0; i < values.size(); i++) {
265+
for (size_t i = 0; i < values.size(); i++) {
266266
NANOARROW_RETURN_NOT_OK(ArrowArrayAppendInt(array, values[i]));
267267
}
268268

@@ -293,7 +293,7 @@ static void BenchmarkArrayAppendString(benchmark::State& state) {
293293
int64_t value_size = 7;
294294

295295
std::vector<std::string> values(n_values);
296-
int64_t alphabet_pos = 0;
296+
size_t alphabet_pos = 0;
297297
for (std::string& value : values) {
298298
if ((alphabet_pos + value_size) >= kAlphabet.size()) {
299299
alphabet_pos = 0;
@@ -361,7 +361,7 @@ static ArrowErrorCode CreateAndAppendIntWithNulls(ArrowArray* array,
361361
NANOARROW_RETURN_NOT_OK(ArrowArrayStartAppending(array));
362362
CType non_null_value = std::numeric_limits<CType>::max() / 2;
363363

364-
for (int64_t i = 0; i < validity.size(); i++) {
364+
for (size_t i = 0; i < validity.size(); i++) {
365365
if (validity[i]) {
366366
NANOARROW_RETURN_NOT_OK(ArrowArrayAppendInt(array, non_null_value));
367367
} else {

‎src/nanoarrow/array_test.cc

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -848,9 +848,9 @@ TEST(ArrayTest, ArrayTestAppendToFixedSizeBinaryArray) {
848848
ASSERT_EQ(ArrowArrayReserve(&array, 5), NANOARROW_OK);
849849
EXPECT_EQ(ArrowArrayBuffer(&array, 1)->capacity_bytes, 5 * 5);
850850

851-
EXPECT_EQ(ArrowArrayAppendBytes(&array, {"12345", 5}), NANOARROW_OK);
851+
EXPECT_EQ(ArrowArrayAppendBytes(&array, {{"12345"}, 5}), NANOARROW_OK);
852852
EXPECT_EQ(ArrowArrayAppendNull(&array, 2), NANOARROW_OK);
853-
EXPECT_EQ(ArrowArrayAppendBytes(&array, {"67890", 5}), NANOARROW_OK);
853+
EXPECT_EQ(ArrowArrayAppendBytes(&array, {{"67890"}, 5}), NANOARROW_OK);
854854
EXPECT_EQ(ArrowArrayAppendEmpty(&array, 1), NANOARROW_OK);
855855
EXPECT_EQ(ArrowArrayFinishBuildingDefault(&array, nullptr), NANOARROW_OK);
856856

‎src/nanoarrow/buffer_test.cc

Lines changed: 12 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -29,6 +29,7 @@
2929
static uint8_t* TestAllocatorReallocate(struct ArrowBufferAllocator* allocator,
3030
uint8_t* ptr, int64_t old_size,
3131
int64_t new_size) {
32+
NANOARROW_UNUSED(allocator);
3233
uint8_t* new_ptr = reinterpret_cast<uint8_t*>(malloc(new_size));
3334

3435
int64_t copy_size = std::min<int64_t>(old_size, new_size);
@@ -45,6 +46,8 @@ static uint8_t* TestAllocatorReallocate(struct ArrowBufferAllocator* allocator,
4546

4647
static void TestAllocatorFree(struct ArrowBufferAllocator* allocator, uint8_t* ptr,
4748
int64_t size) {
49+
NANOARROW_UNUSED(allocator);
50+
NANOARROW_UNUSED(size);
4851
free(ptr);
4952
}
5053

@@ -188,31 +191,31 @@ TEST(BufferTest, BufferTestAppendHelpers) {
188191
ArrowBufferReset(&buffer);
189192

190193
EXPECT_EQ(ArrowBufferAppendUInt8(&buffer, 123), NANOARROW_OK);
191-
EXPECT_EQ(reinterpret_cast<uint8_t*>(buffer.data)[0], 123);
194+
EXPECT_EQ(reinterpret_cast<uint8_t*>(buffer.data)[0], 123U);
192195
ArrowBufferReset(&buffer);
193196

194197
EXPECT_EQ(ArrowBufferAppendInt16(&buffer, 123), NANOARROW_OK);
195198
EXPECT_EQ(reinterpret_cast<int16_t*>(buffer.data)[0], 123);
196199
ArrowBufferReset(&buffer);
197200

198201
EXPECT_EQ(ArrowBufferAppendUInt16(&buffer, 123), NANOARROW_OK);
199-
EXPECT_EQ(reinterpret_cast<uint16_t*>(buffer.data)[0], 123);
202+
EXPECT_EQ(reinterpret_cast<uint16_t*>(buffer.data)[0], 123U);
200203
ArrowBufferReset(&buffer);
201204

202205
EXPECT_EQ(ArrowBufferAppendInt32(&buffer, 123), NANOARROW_OK);
203206
EXPECT_EQ(reinterpret_cast<int32_t*>(buffer.data)[0], 123);
204207
ArrowBufferReset(&buffer);
205208

206209
EXPECT_EQ(ArrowBufferAppendUInt32(&buffer, 123), NANOARROW_OK);
207-
EXPECT_EQ(reinterpret_cast<uint32_t*>(buffer.data)[0], 123);
210+
EXPECT_EQ(reinterpret_cast<uint32_t*>(buffer.data)[0], 123U);
208211
ArrowBufferReset(&buffer);
209212

210213
EXPECT_EQ(ArrowBufferAppendInt64(&buffer, 123), NANOARROW_OK);
211214
EXPECT_EQ(reinterpret_cast<int64_t*>(buffer.data)[0], 123);
212215
ArrowBufferReset(&buffer);
213216

214217
EXPECT_EQ(ArrowBufferAppendUInt64(&buffer, 123), NANOARROW_OK);
215-
EXPECT_EQ(reinterpret_cast<uint64_t*>(buffer.data)[0], 123);
218+
EXPECT_EQ(reinterpret_cast<uint64_t*>(buffer.data)[0], 123U);
216219
ArrowBufferReset(&buffer);
217220

218221
EXPECT_EQ(ArrowBufferAppendDouble(&buffer, 123), NANOARROW_OK);
@@ -241,7 +244,7 @@ TEST(BitmapTest, BitmapTestElement) {
241244
uint8_t bitmap[10];
242245

243246
memset(bitmap, 0xff, sizeof(bitmap));
244-
for (int i = 0; i < sizeof(bitmap) * 8; i++) {
247+
for (size_t i = 0; i < sizeof(bitmap) * 8; i++) {
245248
EXPECT_EQ(ArrowBitGet(bitmap, i), 1);
246249
}
247250

@@ -256,7 +259,7 @@ TEST(BitmapTest, BitmapTestElement) {
256259
EXPECT_EQ(ArrowBitGet(bitmap, 16 + 7), 1);
257260

258261
memset(bitmap, 0x00, sizeof(bitmap));
259-
for (int i = 0; i < sizeof(bitmap) * 8; i++) {
262+
for (size_t i = 0; i < sizeof(bitmap) * 8; i++) {
260263
EXPECT_EQ(ArrowBitGet(bitmap, i), 0);
261264
}
262265

@@ -271,7 +274,7 @@ TEST(BitmapTest, BitmapTestElement) {
271274
EXPECT_EQ(ArrowBitGet(bitmap, 16 + 7), 0);
272275
}
273276

274-
template <int offset, int length>
277+
template <int offset, size_t length>
275278
void TestArrowBitmapUnpackUnsafe(const uint8_t* bitmap, std::vector<int8_t> expected) {
276279
int8_t out[length];
277280
int32_t out32[length];
@@ -281,12 +284,12 @@ void TestArrowBitmapUnpackUnsafe(const uint8_t* bitmap, std::vector<int8_t> expe
281284
ASSERT_EQ(length, expected.size());
282285

283286
ArrowBitsUnpackInt8(bitmap, offset, length, out);
284-
for (int i = 0; i < length; i++) {
287+
for (size_t i = 0; i < length; i++) {
285288
EXPECT_EQ(out[i], expected[i]);
286289
}
287290

288291
ArrowBitsUnpackInt32(bitmap, offset, length, out32);
289-
for (int i = 0; i < length; i++) {
292+
for (size_t i = 0; i < length; i++) {
290293
EXPECT_EQ(out32[i], expected[i]);
291294
}
292295
}

‎src/nanoarrow/integration/c_data_integration.cc

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,7 @@ static int64_t kBytesAllocated = 0;
2828

2929
static uint8_t* IntegrationTestReallocate(ArrowBufferAllocator* allocator, uint8_t* ptr,
3030
int64_t old_size, int64_t new_size) {
31+
NANOARROW_UNUSED(allocator);
3132
ArrowBufferAllocator default_allocator = ArrowBufferAllocatorDefault();
3233
kBytesAllocated -= old_size;
3334
uint8_t* out =
@@ -41,6 +42,7 @@ static uint8_t* IntegrationTestReallocate(ArrowBufferAllocator* allocator, uint8
4142

4243
static void IntegrationTestFree(struct ArrowBufferAllocator* allocator, uint8_t* ptr,
4344
int64_t size) {
45+
NANOARROW_UNUSED(allocator);
4446
ArrowBufferAllocator default_allocator = ArrowBufferAllocatorDefault();
4547
kBytesAllocated -= size;
4648
default_allocator.free(&default_allocator, ptr, size);

‎src/nanoarrow/nanoarrow.hpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -244,6 +244,8 @@ class Unique {
244244
template <typename T>
245245
static inline void DeallocateWrappedBuffer(struct ArrowBufferAllocator* allocator,
246246
uint8_t* ptr, int64_t size) {
247+
NANOARROW_UNUSED(ptr);
248+
NANOARROW_UNUSED(size);
247249
auto obj = reinterpret_cast<T*>(allocator->private_data);
248250
delete obj;
249251
}

‎src/nanoarrow/nanoarrow_testing.hpp

Lines changed: 13 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1105,7 +1105,7 @@ class TestingJSONReader {
11051105
} else if (num_batch == kNumBatchReadAll) {
11061106
batch_ids.resize(batches.size());
11071107
std::iota(batch_ids.begin(), batch_ids.end(), 0);
1108-
} else if (num_batch >= 0 && num_batch < batches.size()) {
1108+
} else if (num_batch >= 0 && static_cast<size_t>(num_batch) < batches.size()) {
11091109
batch_ids.push_back(num_batch);
11101110
} else {
11111111
ArrowErrorSet(error, "Expected num_batch between 0 and %d but got %d",
@@ -1887,8 +1887,9 @@ class TestingJSONReader {
18871887
const auto& columns = value["columns"];
18881888
NANOARROW_RETURN_NOT_OK(
18891889
Check(columns.is_array(), error, "RecordBatch columns must be array"));
1890-
NANOARROW_RETURN_NOT_OK(Check(columns.size() == array_view->n_children, error,
1891-
"RecordBatch children has incorrect size"));
1890+
NANOARROW_RETURN_NOT_OK(
1891+
Check(columns.size() == static_cast<size_t>(array_view->n_children), error,
1892+
"RecordBatch children has incorrect size"));
18921893

18931894
for (int64_t i = 0; i < array_view->n_children; i++) {
18941895
NANOARROW_RETURN_NOT_OK(SetArrayColumn(columns[i], schema->children[i],
@@ -1987,8 +1988,9 @@ class TestingJSONReader {
19871988
const auto& children = value["children"];
19881989
NANOARROW_RETURN_NOT_OK(
19891990
Check(children.is_array(), error, error_prefix + "children must be array"));
1990-
NANOARROW_RETURN_NOT_OK(Check(children.size() == array_view->n_children, error,
1991-
error_prefix + "children has incorrect size"));
1991+
NANOARROW_RETURN_NOT_OK(
1992+
Check(children.size() == static_cast<size_t>(array_view->n_children), error,
1993+
error_prefix + "children has incorrect size"));
19921994

19931995
for (int64_t i = 0; i < array_view->n_children; i++) {
19941996
NANOARROW_RETURN_NOT_OK(SetArrayColumn(children[i], schema->children[i],
@@ -2272,7 +2274,8 @@ class TestingJSONReader {
22722274
// Check offsets against values
22732275
const T* expected_offset = reinterpret_cast<const T*>(offsets->data);
22742276
NANOARROW_RETURN_NOT_OK(Check(
2275-
offsets->size_bytes == ((value.size() + 1) * sizeof(T)), error,
2277+
static_cast<size_t>(offsets->size_bytes) == ((value.size() + 1) * sizeof(T)),
2278+
error,
22762279
"Expected offset buffer with " + std::to_string(value.size()) + " elements"));
22772280
NANOARROW_RETURN_NOT_OK(
22782281
Check(*expected_offset++ == 0, error, "first offset must be zero"));
@@ -2310,7 +2313,8 @@ class TestingJSONReader {
23102313
// Check offsets against values if not fixed size
23112314
const T* expected_offset = reinterpret_cast<const T*>(offsets->data);
23122315
NANOARROW_RETURN_NOT_OK(Check(
2313-
offsets->size_bytes == ((value.size() + 1) * sizeof(T)), error,
2316+
static_cast<size_t>(offsets->size_bytes) == ((value.size() + 1) * sizeof(T)),
2317+
error,
23142318
"Expected offset buffer with " + std::to_string(value.size()) + " elements"));
23152319
NANOARROW_RETURN_NOT_OK(
23162320
Check(*expected_offset++ == 0, error, "first offset must be zero"));
@@ -2355,7 +2359,7 @@ class TestingJSONReader {
23552359
Check(item.is_string(), error, "binary data buffer item must be string"));
23562360
auto item_str = item.get<std::string>();
23572361

2358-
int64_t item_size_bytes = item_str.size() / 2;
2362+
size_t item_size_bytes = item_str.size() / 2;
23592363
NANOARROW_RETURN_NOT_OK(Check((item_size_bytes * 2) == item_str.size(), error,
23602364
"binary data buffer item must have even size"));
23612365

@@ -2502,7 +2506,7 @@ class TestingJSONComparison {
25022506

25032507
public:
25042508
/// \brief Returns the number of differences found by the previous call
2505-
size_t num_differences() const { return differences_.size(); }
2509+
int64_t num_differences() const { return differences_.size(); }
25062510

25072511
/// \brief Dump a human-readable summary of differences to out
25082512
void WriteDifferences(std::ostream& out) {

0 commit comments

Comments
 (0)