Method from

arrow-array/src/array/run_array.rs:358–397

The method assumes the caller already validated the data using `ArrayData::validate_data()`

(data: ArrayData)

impl<R: RunEndIndexType> From<ArrayData> for RunArray<R> {
    // The method assumes the caller already validated the data using `ArrayData::validate_data()`
    fn from(data: ArrayData) -> Self {
        let (data_type, len, _nulls, offset, _buffers, child_data) = data.into_parts();

        match &data_type {
            DataType::RunEndEncoded(_, _) => {}
            _ => {
                panic!(
                    "Invalid data type {data_type:?} for RunArray. Should be DataType::RunEndEncoded"
                );
            }
        }

        let [run_end_child, values_child]: [ArrayData; 2] = child_data
            .try_into()
            .expect("RunArray data should have exactly two child arrays");

        // deconstruct the run ends child array
        let (
            run_end_data_type,
            _run_end_len,
            _run_end_nulls,
            _run_end_offset,
            run_end_buffers,
            _run_end_child_data,
        ) = run_end_child.into_parts();
        assert_eq!(run_end_data_type, R::DATA_TYPE, "Incorrect run ends type");
        let [run_end_buffer]: [arrow_buffer::Buffer; 1] = run_end_buffers
            .try_into()
            .expect("Run ends should have exactly one buffer");
        let scalar = ScalarBuffer::from(run_end_buffer);
        let run_ends = unsafe { RunEndBuffer::new_unchecked(scalar, offset, len) };

        let values = make_array(values_child);

        Self {
            data_type,
            run_ends,
            values,
        }
    }
}

impl<R: RunEndIndexType> From<RunArray<R>> for ArrayData {