Function createListInt64Array

test/include/arrow_test_utils.h:431–516

LIST array helper

// LIST<INT64> array helper
inline void createListInt64Array(ArrowArray* array,
    const std::vector<std::vector<int64_t>>& lists) {
    int32_t total = 0;
    for (const auto& lst : lists) {
        total += static_cast<int32_t>(lst.size());
    }

    auto* offsets = static_cast<int32_t*>(malloc((lists.size() + 1) * sizeof(int32_t)));
    offsets[0] = 0;
    for (size_t i = 0; i < lists.size(); ++i) {
        offsets[i + 1] = offsets[i] + static_cast<int32_t>(lists[i].size());
    }

    auto* values = static_cast<int64_t*>(malloc(total > 0 ? total * sizeof(int64_t) : 1));
    int32_t pos = 0;
    for (const auto& lst : lists) {
        for (auto value : lst) {
            values[pos++] = value;
        }
    }

    struct ChildPD {
        int64_t* values;
    };
    auto* childPrivateData = new ChildPD{values};
    auto* child = static_cast<ArrowArray*>(malloc(sizeof(ArrowArray)));
    child->length = total;
    child->null_count = 0;
    child->offset = 0;
    child->n_buffers = 2;
    child->n_children = 0;
    child->buffers = static_cast<const void**>(malloc(sizeof(void*) * 2));
    child->buffers[0] = nullptr;
    child->buffers[1] = values;
    child->children = nullptr;
    child->dictionary = nullptr;
    child->release = [](ArrowArray* a) {
        if (a->private_data) {
            auto* privateData = static_cast<ChildPD*>(a->private_data);
            free(privateData->values);
            delete privateData;
        }
        if (a->buffers) {
            free(const_cast<void**>(a->buffers));
        }
        a->release = nullptr;
    };
    child->private_data = childPrivateData;

    struct ListPD {
        int32_t* offsets;
    };
    auto* listPrivateData = new ListPD{offsets};
    array->length = static_cast<int64_t>(lists.size());
    array->null_count = 0;
    array->offset = 0;
    array->n_buffers = 2;
    array->n_children = 1;