miniextendr_api/altrep_data/

builtins.rs

//! Built-in ALTREP data implementations for standard Rust types.
//!
//! Provides `AltIntegerData`, `AltRealData`, `AltLogicalData`, `AltRawData`,
//! `AltStringData`, and `AltComplexData` implementations for:
//!
//! - `Vec<T>` — owned vector (most common)
//! - `Box<[T]>` — boxed slice
//! - `Range<T>` — lazy arithmetic sequences (integer, real)
//! - `&'static [T]` — borrowed slices (zero-copy from static data)
//! - `[T; N]` — fixed-size arrays

use std::borrow::Cow;
use std::ops::Range;

use crate::{IsNA, RLogical, Rcomplex, SEXP};

use super::{
    AltComplexData, AltIntegerData, AltLogicalData, AltRawData, AltRealData, AltStringData,
    AltrepDataptr, AltrepLen, AltrepSerialize, Logical, Sortedness,
};

// region: Helper macros to reduce repetition

/// Implement AltrepLen for Vec<$elem>
macro_rules! impl_len_vec {
    ($elem:ty) => {
        impl AltrepLen for Vec<$elem> {
            fn altrep_len(&self) -> usize {
                Vec::len(self)
            }
        }
    };
}

/// Implement AltrepLen for Box<[$elem]>
macro_rules! impl_len_boxed {
    ($elem:ty) => {
        impl AltrepLen for Box<[$elem]> {
            fn altrep_len(&self) -> usize {
                <[$elem]>::len(self)
            }
        }
    };
}

/// Implement AltrepLen for [$elem; N]
macro_rules! impl_len_array {
    ($elem:ty) => {
        impl<const N: usize> AltrepLen for [$elem; N] {
            fn altrep_len(&self) -> usize {
                N
            }
        }
    };
}

/// Implement AltrepLen for &[$elem]
macro_rules! impl_len_slice {
    ($elem:ty) => {
        impl AltrepLen for &[$elem] {
            fn altrep_len(&self) -> usize {
                <[$elem]>::len(self)
            }
        }
    };
}

/// Implement AltrepDataptr for Vec<$elem> (types with direct memory access)
macro_rules! impl_dataptr_vec {
    ($elem:ty) => {
        impl_dataptr_vec!($elem => $elem);
    };
    // The storage type must have the same layout and valid bit patterns.
    ($elem:ty => $storage:ty) => {
        impl AltrepDataptr<$storage> for Vec<$elem> {
            fn dataptr(&mut self, _writable: bool) -> Option<*mut $storage> {
                Some(self.as_mut_ptr().cast())
            }

            fn dataptr_or_null(&self) -> Option<*const $storage> {
                Some(self.as_ptr().cast())
            }
        }
    };
}

/// Implement AltrepDataptr for Box<[$elem]> (types with direct memory access)
macro_rules! impl_dataptr_boxed {
    ($elem:ty) => {
        impl_dataptr_boxed!($elem => $elem);
    };
    // The storage type must have the same layout and valid bit patterns.
    ($elem:ty => $storage:ty) => {
        impl AltrepDataptr<$storage> for Box<[$elem]> {
            fn dataptr(&mut self, _writable: bool) -> Option<*mut $storage> {
                Some(self.as_mut_ptr().cast())
            }

            fn dataptr_or_null(&self) -> Option<*const $storage> {
                Some(self.as_ptr().cast())
            }
        }
    };
}

/// Implement AltrepSerialize for types that can be cloned and converted to/from R.
///
/// This serializes by converting to a native R vector, ensuring the data survives
/// even if the Rust package isn't loaded when unserializing.
macro_rules! impl_serialize {
    ($ty:ty) => {
        impl_serialize!($ty, $ty, std::convert::identity);
    };
    ($ty:ty, $owned:ty, $wrap:expr) => {
        impl AltrepSerialize for $ty {
            fn serialized_state(&self) -> SEXP {
                use crate::into_r::IntoR;
                self.clone().into_sexp()
            }

            fn unserialize(state: SEXP) -> Option<Self> {
                use crate::from_r::TryFromSexp;
                <$owned>::try_from_sexp(state).ok().map($wrap)
            }
        }
    };
}
// endregion

// region: Slice-backed family macros
//
// The numeric / raw / complex ALTREP families share byte-identical bodies
// across every container shape that derefs to `[T]` (`Vec<T>`, `Box<[T]>`,
// `&[T]`, `Cow<'static, [T]>`). The element type is the only axis that varies
// the *behaviour* (NA sentinel + statistic semantics); the container shape only
// varies how the slice is spelled. Each macro below collapses one element
// family across all slice-like containers by writing every method body against
// the deref'd `&[$elem]` slice.
//
// `[T; N]` arrays are intentionally NOT routed through these macros: they need
// `impl<const N: usize>` (not expressible via `$ty:ty`) and they deliberately
// omit `sum`/`min`/`max` (falling back to R's defaults). `Range<T>` is lazy and
// has its own arithmetic-sequence bodies. The string families have per-type
// `elt`/`no_na` differences and stay hand-written.

/// `AltIntegerData` for any container that derefs to `[i32]`.
///
/// `s` binds the underlying `&[i32]` uniformly across `Vec` / `Box<[T]>` /
/// `&[T]` / `Cow`, using the same slice access for every owner.
macro_rules! impl_altinteger_slice {
    ($ty:ty) => {
        impl AltIntegerData for $ty {
            fn elt(&self, i: usize) -> i32 {
                self[i]
            }

            fn as_slice(&self) -> Option<&[i32]> {
                let s: &[i32] = self;
                Some(s)
            }

            fn get_region(&self, start: usize, len: usize, buf: &mut [i32]) -> usize {
                let s: &[i32] = self;
                let end = (start + len).min(s.len());
                let actual_len = end.saturating_sub(start);
                if actual_len > 0 {
                    buf[..actual_len].copy_from_slice(&s[start..end]);
                }
                actual_len
            }

            fn no_na(&self) -> Option<bool> {
                let s: &[i32] = self;
                Some(!s.iter().any(IsNA::is_na))
            }

            fn sum(&self, na_rm: bool) -> Option<i64> {
                let s: &[i32] = self;
                let mut sum: i64 = 0;
                for &x in s.iter() {
                    if x.is_na() {
                        if !na_rm {
                            return None; // NA propagates
                        }
                    } else {
                        sum += x as i64;
                    }
                }
                Some(sum)
            }

            fn min(&self, na_rm: bool) -> Option<i32> {
                let s: &[i32] = self;
                let mut min = i32::MAX;
                let mut found = false;
                for &x in s.iter() {
                    if x.is_na() {
                        if !na_rm {
                            return None;
                        }
                    } else {
                        found = true;
                        min = min.min(x);
                    }
                }
                if found { Some(min) } else { None }
            }

            fn max(&self, na_rm: bool) -> Option<i32> {
                let s: &[i32] = self;
                let mut max = i32::MIN + 1; // i32::MIN is the NA sentinel
                let mut found = false;
                for &x in s.iter() {
                    if x.is_na() {
                        if !na_rm {
                            return None;
                        }
                    } else {
                        found = true;
                        max = max.max(x);
                    }
                }
                if found { Some(max) } else { None }
            }
        }
    };
}

// region: double NA/NaN summaries shared by the slice-backed AltRealData impls

/// `no_na` for a double slice: `true` only when no element is `NA` **or** `NaN`.
///
/// This is R's `ISNAN` test, not `R_IsNA`: `anyNA()` returns `FALSE` as soon as
/// `REAL_NO_NA()` reports true (its own scan tests `ISNAN`, so
/// `anyNA(c(1, NaN))` is `TRUE`), and `sort()` uses the same hint to skip its
/// NA handling, which drops NaN too.
fn real_slice_no_na(s: &[f64]) -> bool {
    !s.iter().any(|x| x.is_nan())
}

/// `sum` for a double slice, following R's `rsum`.
///
/// With `na_rm`, every `NA` and `NaN` is skipped (`ISNAN`). Without it, the
/// result is the first element that is R's NA (`R_IsNA`, so a computed NA such
/// as `NA_real_ * 1` counts), else `NaN` if any element is another NaN. R leaves
/// the NA-vs-NaN outcome of a sum unspecified; letting NA win matches `min` and
/// `max`.
fn real_slice_sum(s: &[f64], na_rm: bool) -> f64 {
    let mut sum = 0.0;
    let mut nan = false;
    for &x in s {
        if x.is_nan() {
            if na_rm {
                continue;
            }
            if x.is_na() {
                return x;
            }
            nan = true;
        } else {
            sum += x;
        }
    }
    if nan { f64::NAN } else { sum }
}

/// `min` / `max` for a double slice, following R's `rmin` / `rmax`.
///
/// Missing values are handled as in [`real_slice_sum`]: skipped with `na_rm`,
/// otherwise an NA (`R_IsNA`) wins over a NaN ("any NA trumps all NaNs" in
/// R's source) and is returned as is, bits included, as R's loop does. `None`
/// when nothing is left to compare (R then computes the `Inf` / `-Inf` result
/// and its warning itself).
fn real_slice_extreme(s: &[f64], na_rm: bool, pick: fn(f64, f64) -> f64) -> Option<f64> {
    let mut best: Option<f64> = None;
    let mut nan = false;
    for &x in s {
        if x.is_nan() {
            if na_rm {
                continue;
            }
            if x.is_na() {
                return Some(x);
            }
            nan = true;
        } else {
            best = Some(best.map_or(x, |b| pick(b, x)));
        }
    }
    if nan { Some(f64::NAN) } else { best }
}

// endregion

/// `AltRealData` for any container that derefs to `[f64]`.
///
/// Distinguishes R's `NA_real_` from a regular IEEE NaN where R does: `sum`,
/// `min` and `max` return NA for an NA element and NaN for a NaN element, while
/// `no_na` treats both as missing (see [`real_slice_no_na`]).
macro_rules! impl_altreal_slice {
    ($ty:ty) => {
        impl AltRealData for $ty {
            fn elt(&self, i: usize) -> f64 {
                self[i]
            }

            fn as_slice(&self) -> Option<&[f64]> {
                let s: &[f64] = self;
                Some(s)
            }

            fn get_region(&self, start: usize, len: usize, buf: &mut [f64]) -> usize {
                let s: &[f64] = self;
                let end = (start + len).min(s.len());
                let actual_len = end.saturating_sub(start);
                if actual_len > 0 {
                    buf[..actual_len].copy_from_slice(&s[start..end]);
                }
                actual_len
            }

            fn no_na(&self) -> Option<bool> {
                Some(real_slice_no_na(self))
            }

            fn sum(&self, na_rm: bool) -> Option<f64> {
                Some(real_slice_sum(self, na_rm))
            }

            fn min(&self, na_rm: bool) -> Option<f64> {
                real_slice_extreme(self, na_rm, f64::min)
            }

            fn max(&self, na_rm: bool) -> Option<f64> {
                real_slice_extreme(self, na_rm, f64::max)
            }
        }
    };
}

/// `AltRawData` for any container that derefs to `[u8]`. Raw has no NA.
macro_rules! impl_altraw_slice {
    ($ty:ty) => {
        impl AltRawData for $ty {
            fn elt(&self, i: usize) -> u8 {
                self[i]
            }

            fn as_slice(&self) -> Option<&[u8]> {
                let s: &[u8] = self;
                Some(s)
            }

            fn get_region(&self, start: usize, len: usize, buf: &mut [u8]) -> usize {
                let s: &[u8] = self;
                let end = (start + len).min(s.len());
                let actual_len = end.saturating_sub(start);
                if actual_len > 0 {
                    buf[..actual_len].copy_from_slice(&s[start..end]);
                }
                actual_len
            }
        }
    };
}

/// `AltComplexData` for any container that derefs to `[Rcomplex]`.
macro_rules! impl_altcomplex_slice {
    ($ty:ty) => {
        impl AltComplexData for $ty {
            fn elt(&self, i: usize) -> Rcomplex {
                self[i]
            }

            fn as_slice(&self) -> Option<&[Rcomplex]> {
                let s: &[Rcomplex] = self;
                Some(s)
            }

            fn get_region(&self, start: usize, len: usize, buf: &mut [Rcomplex]) -> usize {
                let s: &[Rcomplex] = self;
                let end = (start + len).min(s.len());
                let actual_len = end.saturating_sub(start);
                if actual_len > 0 {
                    buf[..actual_len].copy_from_slice(&s[start..end]);
                }
                actual_len
            }
        }
    };
}

/// `AltLogicalData` for any container that derefs to `[bool]`. `bool` can't be NA.
macro_rules! impl_altlogical_slice {
    ($ty:ty) => {
        impl AltLogicalData for $ty {
            fn elt(&self, i: usize) -> Logical {
                self[i].into()
            }

            fn no_na(&self) -> Option<bool> {
                Some(true) // bool can't be NA
            }

            fn sum(&self, _na_rm: bool) -> Option<i64> {
                let s: &[bool] = self;
                Some(s.iter().filter(|&&x| x).count() as i64)
            }
        }
    };
}
/// `AltLogicalData` for R-native logical slices, including NA and raw values.
macro_rules! impl_altlogical_native_slice {
    ($ty:ty) => {
        impl AltLogicalData for $ty {
            fn elt(&self, i: usize) -> Logical {
                self[i].into()
            }

            fn as_r_slice(&self) -> Option<&[i32]> {
                let values: &[RLogical] = self;
                // RLogical is repr(transparent) over i32; every bit pattern is valid.
                Some(unsafe { std::slice::from_raw_parts(values.as_ptr().cast(), values.len()) })
            }

            fn get_region(&self, start: usize, len: usize, out: &mut [i32]) -> usize {
                let values: &[RLogical] = self;
                super::fill_region(start, len, values.len(), out, |i| values[i].to_i32())
            }

            fn no_na(&self) -> Option<bool> {
                let values: &[RLogical] = self;
                Some(!values.iter().any(IsNA::is_na))
            }
        }
    };
}
// endregion

// region: AltrepSerialize implementations for Vec<T>

impl_serialize!(Vec<i32>);
impl_serialize!(Vec<f64>);
impl_serialize!(Vec<u8>);
impl_serialize!(Vec<bool>);
impl_serialize!(Vec<RLogical>);
impl_serialize!(Vec<String>);
impl_serialize!(Vec<Option<String>>);
impl_serialize!(Vec<Rcomplex>);
// The ALTREP outlives R's temporary serialization state. Its Rust backing
// must own the decoded strings; no sidecar roots the original CHARSXPs.
impl_serialize!(Vec<Cow<'static, str>>, Vec<String>, |values| {
    values.into_iter().map(Cow::Owned).collect()
});
impl_serialize!(
    Vec<Option<Cow<'static, str>>>,
    Vec<Option<String>>,
    |values| values
        .into_iter()
        .map(|value| value.map(Cow::Owned))
        .collect()
);
// endregion

// region: AltrepSerialize implementations for Box<[T]>

// Box<[T]>'s IntoR and TryFromSexp already delegate to Vec<T>.
impl_serialize!(Box<[i32]>);
impl_serialize!(Box<[f64]>);
impl_serialize!(Box<[u8]>);
impl_serialize!(Box<[bool]>);
impl_serialize!(Box<[RLogical]>);
impl_serialize!(Box<[String]>);
impl_serialize!(Box<[Rcomplex]>);
// endregion

// region: Built-in implementations for Vec<T>

impl_len_vec!(i32);
impl_altinteger_slice!(Vec<i32>);
impl_dataptr_vec!(i32);

impl_len_vec!(f64);
impl_altreal_slice!(Vec<f64>);
impl_dataptr_vec!(f64);

impl_len_vec!(u8);
impl_altraw_slice!(Vec<u8>);
impl_dataptr_vec!(u8);

impl_len_vec!(String);

impl AltStringData for Vec<String> {
    fn elt(&self, i: usize) -> Option<&str> {
        Some(self[i].as_str())
    }

    fn no_na(&self) -> Option<bool> {
        Some(true) // String vectors don't have NA
    }
}

impl_len_vec!(Option<String>);

impl AltStringData for Vec<Option<String>> {
    fn elt(&self, i: usize) -> Option<&str> {
        self[i].as_deref()
    }

    fn no_na(&self) -> Option<bool> {
        Some(!self.iter().any(|x| x.is_none()))
    }
}

impl AltrepLen for Vec<std::borrow::Cow<'static, str>> {
    fn altrep_len(&self) -> usize {
        self.len()
    }
}

impl AltStringData for Vec<std::borrow::Cow<'static, str>> {
    fn elt(&self, i: usize) -> Option<&str> {
        Some(self[i].as_ref())
    }

    fn no_na(&self) -> Option<bool> {
        Some(true) // Cow vectors don't have NA
    }
}

impl AltrepLen for Vec<Option<std::borrow::Cow<'static, str>>> {
    fn altrep_len(&self) -> usize {
        self.len()
    }
}

impl AltStringData for Vec<Option<std::borrow::Cow<'static, str>>> {
    fn elt(&self, i: usize) -> Option<&str> {
        self[i].as_deref()
    }

    fn no_na(&self) -> Option<bool> {
        Some(!self.iter().any(|x| x.is_none()))
    }
}

impl_len_vec!(bool);
impl_altlogical_slice!(Vec<bool>);

impl_len_vec!(RLogical);
impl_altlogical_native_slice!(Vec<RLogical>);
impl_dataptr_vec!(RLogical => i32);
// endregion

// region: Built-in implementations for Box<[T]> (owned slices)
// Box<[T]> is a fat pointer (Sized) that wraps a DST slice.
// Unlike Vec<T>, it has no capacity field - just ptr + len (2 words).
// This makes it more memory-efficient for fixed-size data.
//
// Box<[T]> CAN be used directly with ALTREP via the proc-macro:
// ```
// #[miniextendr(class = "BoxedInts")]
// pub struct BoxedIntsClass(Box<[i32]>);
// ```
//
// Or use these trait implementations in custom wrapper structs.

impl_len_boxed!(i32);
impl_altinteger_slice!(Box<[i32]>);
impl_dataptr_boxed!(i32);

impl_len_boxed!(f64);
impl_altreal_slice!(Box<[f64]>);
impl_dataptr_boxed!(f64);

impl_len_boxed!(u8);
impl_altraw_slice!(Box<[u8]>);
impl_dataptr_boxed!(u8);

impl_len_boxed!(bool);
impl_altlogical_slice!(Box<[bool]>);

impl_len_boxed!(RLogical);
impl_altlogical_native_slice!(Box<[RLogical]>);
impl_dataptr_boxed!(RLogical => i32);

impl_len_boxed!(String);

impl AltStringData for Box<[String]> {
    fn elt(&self, i: usize) -> Option<&str> {
        Some(self[i].as_str())
    }

    fn no_na(&self) -> Option<bool> {
        Some(true) // String can't be NA
    }
}
// endregion

// region: AltrepSerialize implementations for Range types
// Ranges serialize to a 2-element integer/real vector [start, end].

impl AltrepSerialize for Range<i32> {
    fn serialized_state(&self) -> SEXP {
        use crate::into_r::IntoR;
        vec![self.start, self.end].into_sexp()
    }

    fn unserialize(state: SEXP) -> Option<Self> {
        use crate::from_r::TryFromSexp;
        let v = Vec::<i32>::try_from_sexp(state).ok()?;
        if v.len() == 2 { Some(v[0]..v[1]) } else { None }
    }
}

impl AltrepSerialize for Range<i64> {
    fn serialized_state(&self) -> SEXP {
        use crate::into_r::IntoR;
        // Store i64 bit patterns in f64 slots for lossless round-trip.
        // Plain `as f64` loses precision for values > 2^53.
        vec![
            f64::from_bits(self.start as u64),
            f64::from_bits(self.end as u64),
        ]
        .into_sexp()
    }

    fn unserialize(state: SEXP) -> Option<Self> {
        use crate::from_r::TryFromSexp;
        let v = Vec::<f64>::try_from_sexp(state).ok()?;
        if v.len() == 2 {
            Some((v[0].to_bits() as i64)..(v[1].to_bits() as i64))
        } else {
            None
        }
    }
}

impl AltrepSerialize for Range<f64> {
    fn serialized_state(&self) -> SEXP {
        use crate::into_r::IntoR;
        vec![self.start, self.end].into_sexp()
    }

    fn unserialize(state: SEXP) -> Option<Self> {
        use crate::from_r::TryFromSexp;
        let v = Vec::<f64>::try_from_sexp(state).ok()?;
        if v.len() == 2 { Some(v[0]..v[1]) } else { None }
    }
}
// endregion

// region: Built-in implementations for Range types

impl AltrepLen for Range<i32> {
    fn altrep_len(&self) -> usize {
        if self.end > self.start {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl AltIntegerData for Range<i32> {
    fn elt(&self, i: usize) -> i32 {
        self.start + i as i32
    }

    fn is_sorted(&self) -> Option<Sortedness> {
        Some(Sortedness::Increasing)
    }

    fn no_na(&self) -> Option<bool> {
        // i32::MIN is NA_INTEGER in R. Check if the range contains it.
        // Range is [start, end), so i32::MIN is included iff start <= i32::MIN < end
        // Since start is the smallest value, we just check if start == i32::MIN
        let contains_na = self.start.is_na() && self.end > i32::MIN;
        Some(!contains_na)
    }

    fn sum(&self, na_rm: bool) -> Option<i64> {
        let n = AltrepLen::altrep_len(self) as i64;
        if n == 0 {
            return Some(0);
        }

        // Check if range contains NA (i32::MIN)
        let contains_na = self.start.is_na() && self.end > i32::MIN;
        if contains_na && !na_rm {
            return None; // NA propagates
        }

        // Sum of arithmetic sequence: n/2 * (first + last)
        // If na_rm and contains NA, exclude the first element (i32::MIN)
        if contains_na {
            // Exclude first element (NA), sum from start+1 to end-1
            let n_valid = n - 1;
            if n_valid == 0 {
                return Some(0);
            }
            let first = (self.start + 1) as i64;
            let last = (self.end - 1) as i64;
            Some(n_valid * (first + last) / 2)
        } else {
            let first = self.start as i64;
            let last = (self.end - 1) as i64;
            Some(n * (first + last) / 2)
        }
    }

    fn min(&self, na_rm: bool) -> Option<i32> {
        if AltrepLen::altrep_len(self) == 0 {
            return None;
        }

        // Check if first element is NA
        if self.start.is_na() {
            if na_rm {
                // Skip NA, return second element if it exists
                if self.end > self.start + 1 {
                    Some(self.start + 1)
                } else {
                    None // Only element was NA
                }
            } else {
                None // NA propagates
            }
        } else {
            Some(self.start)
        }
    }

    fn max(&self, na_rm: bool) -> Option<i32> {
        if AltrepLen::altrep_len(self) == 0 {
            return None;
        }

        // For increasing range, max is end-1 (last element)
        // Check if range contains NA (first element)
        let contains_na = self.start.is_na() && self.end > i32::MIN;
        if contains_na && !na_rm {
            return None; // NA propagates
        }

        // Max is always end-1 (last element), which is not NA
        // (NA would only be first element if start == i32::MIN)
        Some(self.end - 1)
    }
}

impl AltrepLen for Range<i64> {
    fn altrep_len(&self) -> usize {
        if self.end > self.start {
            (self.end - self.start) as usize
        } else {
            0
        }
    }
}

impl AltIntegerData for Range<i64> {
    fn elt(&self, i: usize) -> i32 {
        let val = self.start.saturating_add(i as i64);
        // Bounds check: return NA_INTEGER for values outside i32 range
        // Also, i32::MIN is the NA sentinel, so values equal to it are NA
        if val > i32::MAX as i64 || val <= i32::MIN as i64 {
            crate::altrep_traits::NA_INTEGER
        } else {
            val as i32
        }
    }

    fn is_sorted(&self) -> Option<Sortedness> {
        Some(Sortedness::Increasing)
    }

    fn no_na(&self) -> Option<bool> {
        // An element is NA if:
        // 1. It's outside valid i32 range (< i32::MIN or > i32::MAX)
        // 2. It equals i32::MIN (NA sentinel)
        //
        // For increasing range [start, end), elements range from start to end-1.
        // Range contains NA if:
        // - start <= i32::MIN as i64 (NA sentinel could be in range)
        // - OR end > i32::MAX as i64 + 1 (values exceed i32::MAX)
        // - OR start < i32::MIN as i64 (values below i32 range)
        let na_sentinel = i32::MIN as i64;
        let i32_max = i32::MAX as i64;

        // Check if NA sentinel is in [start, end)
        let contains_na_sentinel = self.start <= na_sentinel && self.end > na_sentinel;

        // Check if any values are outside valid i32 range
        // Valid range for ALTREP integers: (i32::MIN, i32::MAX] (excluding NA sentinel)
        let has_underflow = self.start < na_sentinel;
        let has_overflow = (self.end - 1) > i32_max;

        Some(!contains_na_sentinel && !has_underflow && !has_overflow)
    }

    fn sum(&self, na_rm: bool) -> Option<i64> {
        let n = AltrepLen::altrep_len(self) as i64;
        if n == 0 {
            return Some(0);
        }

        // Check if range contains any NA values
        let na_sentinel = i32::MIN as i64;
        let i32_max = i32::MAX as i64;
        let contains_na_sentinel = self.start <= na_sentinel && self.end > na_sentinel;
        let has_underflow = self.start < na_sentinel;
        let has_overflow = (self.end - 1) > i32_max;
        let has_na = contains_na_sentinel || has_underflow || has_overflow;

        if has_na && !na_rm {
            return None; // NA propagates
        }

        if has_na {
            // When na_rm=true, we need to exclude NA values
            // This is complex for ranges with out-of-bounds values, so let R compute
            return None;
        }

        let first = self.start;
        let last = self.end - 1;

        // Use checked arithmetic to detect overflow
        // Formula: n * (first + last) / 2
        let sum_endpoints = first.checked_add(last)?;
        let product = n.checked_mul(sum_endpoints)?;
        Some(product / 2)
    }

    fn min(&self, na_rm: bool) -> Option<i32> {
        if AltrepLen::altrep_len(self) == 0 {
            return None;
        }

        let na_sentinel = i32::MIN as i64;
        let i32_max = i32::MAX as i64;

        // Check for NA conditions
        let contains_na_sentinel = self.start <= na_sentinel && self.end > na_sentinel;
        let has_underflow = self.start < na_sentinel;
        let has_overflow = (self.end - 1) > i32_max;
        let has_na = contains_na_sentinel || has_underflow || has_overflow;

        if has_na && !na_rm {
            return None; // NA propagates
        }

        if has_na {
            // Complex case: need to find first non-NA value
            // Let R compute this
            return None;
        }

        // No NA, return start (which is within valid i32 range)
        Some(self.start as i32)
    }

    fn max(&self, na_rm: bool) -> Option<i32> {
        if AltrepLen::altrep_len(self) == 0 {
            return None;
        }

        let na_sentinel = i32::MIN as i64;
        let i32_max = i32::MAX as i64;

        // Check for NA conditions
        let contains_na_sentinel = self.start <= na_sentinel && self.end > na_sentinel;
        let has_underflow = self.start < na_sentinel;
        let has_overflow = (self.end - 1) > i32_max;
        let has_na = contains_na_sentinel || has_underflow || has_overflow;

        if has_na && !na_rm {
            return None; // NA propagates
        }

        if has_na {
            // Complex case: need to find last non-NA value
            // Let R compute this
            return None;
        }

        // No NA, return end-1 (which is within valid i32 range)
        Some((self.end - 1) as i32)
    }
}

impl AltrepLen for Range<f64> {
    fn altrep_len(&self) -> usize {
        // For f64 ranges, assume step of 1.0
        if self.end > self.start {
            (self.end - self.start).ceil() as usize
        } else {
            0
        }
    }
}

impl AltRealData for Range<f64> {
    fn elt(&self, i: usize) -> f64 {
        self.start + i as f64
    }

    fn is_sorted(&self) -> Option<Sortedness> {
        Some(Sortedness::Increasing)
    }

    fn no_na(&self) -> Option<bool> {
        Some(true)
    }

    fn sum(&self, _na_rm: bool) -> Option<f64> {
        let n = AltrepLen::altrep_len(self) as f64;
        if n == 0.0 {
            return Some(0.0);
        }
        let first = self.start;
        let last = self.start + (n - 1.0);
        Some(n * (first + last) / 2.0)
    }

    fn min(&self, _na_rm: bool) -> Option<f64> {
        if AltrepLen::altrep_len(self) > 0 {
            Some(self.start)
        } else {
            None
        }
    }

    fn max(&self, _na_rm: bool) -> Option<f64> {
        if AltrepLen::altrep_len(self) > 0 {
            Some(self.start + (AltrepLen::altrep_len(self) - 1) as f64)
        } else {
            None
        }
    }
}
// endregion

// region: Built-in implementations for slices (read-only)

impl_len_slice!(i32);
impl_altinteger_slice!(&[i32]);

impl_len_slice!(f64);
impl_altreal_slice!(&[f64]);

impl_len_slice!(u8);
impl_altraw_slice!(&[u8]);

impl_len_slice!(bool);
impl_altlogical_slice!(&[bool]);

impl_len_slice!(String);

impl AltStringData for &[String] {
    fn elt(&self, i: usize) -> Option<&str> {
        Some(self[i].as_str())
    }
}

impl_len_slice!(&str);

impl AltStringData for &[&str] {
    fn elt(&self, i: usize) -> Option<&str> {
        Some(self[i])
    }
}
// endregion

// region: NOTE on &'static [T] (static slices)
//
// `&'static [T]` is Sized (fat pointer: ptr + len) and satisfies 'static,
// so it can be used DIRECTLY with ALTREP via ExternalPtr.
//
// The data trait implementations above for `&[T]` already cover `&'static [T]`
// since `&'static [T]` is a subtype of `&[T]`. The ALTREP trait implementations
// (Altrep, AltVec, AltInteger, etc.) are provided separately in altrep_impl.rs.
//
// Use cases:
// - Const arrays: `static DATA: [i32; 5] = [1, 2, 3, 4, 5]; create_altrep(&DATA[..])`
// - Leaked data: `let s: &'static [i32] = Box::leak(vec.into_boxed_slice());`
// - Memory-mapped files with 'static lifetime
// endregion

// region: Built-in implementations for arrays (owned, fixed-size)

// Native arrays live directly inside their ExternalPtr allocation.
macro_rules! impl_dataptr_array {
    ($elem:ty => $storage:ty) => {
        impl<const N: usize> AltrepDataptr<$storage> for [$elem; N] {
            fn dataptr(&mut self, _writable: bool) -> Option<*mut $storage> {
                Some(self.as_mut_ptr().cast())
            }

            fn dataptr_or_null(&self) -> Option<*const $storage> {
                Some(self.as_ptr().cast())
            }
        }
    };
}

impl_dataptr_array!(i32 => i32);
impl_dataptr_array!(f64 => f64);
impl_dataptr_array!(u8 => u8);
impl_dataptr_array!(Rcomplex => Rcomplex);
impl_dataptr_array!(RLogical => i32);

impl_len_array!(RLogical);

impl<const N: usize> AltLogicalData for [RLogical; N] {
    fn elt(&self, i: usize) -> Logical {
        self[i].into()
    }

    fn as_r_slice(&self) -> Option<&[i32]> {
        // RLogical is transparent over i32 and accepts every bit pattern.
        Some(unsafe { std::slice::from_raw_parts(self.as_ptr().cast(), N) })
    }

    fn get_region(&self, start: usize, len: usize, out: &mut [i32]) -> usize {
        super::fill_region(start, len, N, out, |i| self[i].to_i32())
    }

    fn no_na(&self) -> Option<bool> {
        Some(!self.contains(&RLogical::NA))
    }
}

impl_len_array!(i32);

impl<const N: usize> AltIntegerData for [i32; N] {
    fn elt(&self, i: usize) -> i32 {
        self[i]
    }

    fn as_slice(&self) -> Option<&[i32]> {
        Some(self.as_slice())
    }

    fn get_region(&self, start: usize, len: usize, buf: &mut [i32]) -> usize {
        super::fill_region(start, len, N, buf, |i| self[i])
    }

    fn no_na(&self) -> Option<bool> {
        Some(!self.iter().any(IsNA::is_na))
    }
}

impl_len_array!(f64);

impl<const N: usize> AltRealData for [f64; N] {
    fn elt(&self, i: usize) -> f64 {
        self[i]
    }

    fn as_slice(&self) -> Option<&[f64]> {
        Some(self.as_slice())
    }

    fn get_region(&self, start: usize, len: usize, buf: &mut [f64]) -> usize {
        super::fill_region(start, len, N, buf, |i| self[i])
    }

    fn no_na(&self) -> Option<bool> {
        Some(real_slice_no_na(self))
    }
}

impl_len_array!(bool);

impl<const N: usize> AltLogicalData for [bool; N] {
    fn elt(&self, i: usize) -> Logical {
        Logical::from_bool(self[i])
    }

    fn no_na(&self) -> Option<bool> {
        Some(true) // bool arrays can't have NA
    }
}

impl_len_array!(u8);

impl<const N: usize> AltRawData for [u8; N] {
    fn elt(&self, i: usize) -> u8 {
        self[i]
    }

    fn as_slice(&self) -> Option<&[u8]> {
        Some(self.as_slice())
    }

    fn get_region(&self, start: usize, len: usize, buf: &mut [u8]) -> usize {
        super::fill_region(start, len, N, buf, |i| self[i])
    }
}

impl_len_array!(String);

impl<const N: usize> AltStringData for [String; N] {
    fn elt(&self, i: usize) -> Option<&str> {
        Some(self[i].as_str())
    }
}
// endregion

// region: Built-in implementations for Vec<Rcomplex> (complex numbers)

impl_len_vec!(Rcomplex);
impl_altcomplex_slice!(Vec<Rcomplex>);
impl_dataptr_vec!(Rcomplex);
// endregion

// region: Built-in implementations for Box<[Rcomplex]>

impl_len_boxed!(Rcomplex);
impl_altcomplex_slice!(Box<[Rcomplex]>);
impl_dataptr_boxed!(Rcomplex);
// endregion

// region: Built-in implementations for [Rcomplex; N] (complex arrays)

impl_len_array!(Rcomplex);

impl<const N: usize> AltComplexData for [Rcomplex; N] {
    fn elt(&self, i: usize) -> Rcomplex {
        self[i]
    }

    fn as_slice(&self) -> Option<&[Rcomplex]> {
        Some(self.as_slice())
    }

    fn get_region(&self, start: usize, len: usize, buf: &mut [Rcomplex]) -> usize {
        super::fill_region(start, len, N, buf, |i| self[i])
    }
}
// endregion

// region: Vectors of owned unsized strings

macro_rules! impl_owned_str_altrep_data {
    ($owner:ident) => {
        impl_len_vec!($owner<str>);
        impl_len_vec!(Option<$owner<str>>);
        impl AltStringData for Vec<$owner<str>> {
            fn elt(&self, i: usize) -> Option<&str> {
                Some(self[i].as_ref())
            }
            fn no_na(&self) -> Option<bool> {
                Some(true)
            }
        }
        impl AltStringData for Vec<Option<$owner<str>>> {
            fn elt(&self, i: usize) -> Option<&str> {
                self[i].as_deref()
            }
            fn no_na(&self) -> Option<bool> {
                Some(self.iter().all(Option::is_some))
            }
        }
        impl_serialize!(Vec<$owner<str>>);
        impl_serialize!(Vec<Option<$owner<str>>>);
    };
}
impl_owned_str_altrep_data!(Box);
impl_owned_str_altrep_data!(Rc);
impl_owned_str_altrep_data!(Arc);
// endregion

// region: Shared slices

// A unique owner may already have supplied a pointer to R. Shared owners have
// not: Dataptr_or_null refuses them, and Dataptr detaches before exposing one.
// The duplicate callback uses the same rule, so it never re-shares exposed data.
macro_rules! impl_shared_slice_data {
    ($owner:ident) => {
        impl<T> AltrepLen for $owner<[T]> {
            fn altrep_len(&self) -> usize {
                <[T]>::len(self)
            }
        }
        impl_altinteger_slice!($owner<[i32]>);
        impl_altreal_slice!($owner<[f64]>);
        impl_altraw_slice!($owner<[u8]>);
        impl_altcomplex_slice!($owner<[Rcomplex]>);
        impl_altlogical_native_slice!($owner<[RLogical]>);
        impl_altlogical_slice!($owner<[bool]>);
        impl AltStringData for $owner<[String]> {
            fn elt(&self, i: usize) -> Option<&str> {
                Some(&self[i])
            }
            fn no_na(&self) -> Option<bool> {
                Some(true)
            }
        }
    };
}
macro_rules! impl_shared_slice_dataptr {
    ($owner:ident, $elem:ty, $storage:ty) => {
        impl AltrepDataptr<$storage> for $owner<[$elem]> {
            fn dataptr(&mut self, _writable: bool) -> Option<*mut $storage> {
                // Even a read-only pointer request detaches shared storage.
                // This keeps that pointer valid if a later write requests COW.
                Some($owner::make_mut(self).as_mut_ptr().cast())
            }
            fn dataptr_or_null(&self) -> Option<*const $storage> {
                ($owner::strong_count(self) == 1 && $owner::weak_count(self) == 0)
                    .then(|| self.as_ptr().cast())
            }
        }
    };
}
use std::rc::Rc;
use std::sync::Arc;
impl_shared_slice_data!(Rc);
impl_shared_slice_data!(Arc);
impl_shared_slice_dataptr!(Rc, i32, i32);
impl_shared_slice_dataptr!(Rc, f64, f64);
impl_shared_slice_dataptr!(Rc, u8, u8);
impl_shared_slice_dataptr!(Rc, Rcomplex, Rcomplex);
impl_shared_slice_dataptr!(Rc, RLogical, i32);
impl_shared_slice_dataptr!(Arc, i32, i32);
impl_shared_slice_dataptr!(Arc, f64, f64);
impl_shared_slice_dataptr!(Arc, u8, u8);
impl_shared_slice_dataptr!(Arc, Rcomplex, Rcomplex);
impl_shared_slice_dataptr!(Arc, RLogical, i32);
// endregion

// region: Built-in implementations for Cow<'static, [T]>
//
// Cow<'static, [T]> supports static Rust borrows or owned R conversions, retaining
// ownership semantics. Borrowed variants expose the underlying R data directly
// via dataptr; Owned variants behave like Vec<T>. Copy-on-write happens
// automatically when R requests a writable dataptr on a Borrowed variant.

macro_rules! impl_len_cow {
    ($elem:ty) => {
        impl AltrepLen for Cow<'static, [$elem]> {
            fn altrep_len(&self) -> usize {
                <[$elem]>::len(self)
            }
        }
    };
}

macro_rules! impl_dataptr_cow {
    ($elem:ty) => {
        impl_dataptr_cow!($elem => $elem);
    };
    // The storage type must have the same layout and valid bit patterns.
    ($elem:ty => $storage:ty) => {
        impl AltrepDataptr<$storage> for Cow<'static, [$elem]> {
            fn dataptr(&mut self, writable: bool) -> Option<*mut $storage> {
                if writable {
                    // to_mut() triggers copy-on-write for Borrowed variants.
                    // Only do this when R intends to write through the pointer.
                    Some(self.to_mut().as_mut_ptr().cast())
                } else {
                    // Read-only access: return the existing pointer without
                    // forcing a copy for Borrowed variants.
                    Some(self.as_ptr().cast_mut().cast())
                }
            }

            fn dataptr_or_null(&self) -> Option<*const $storage> {
                Some(self.as_ptr().cast())
            }
        }
    };
}

// A restored ALTREP must not borrow the temporary state SEXP: data1 owns
// only the Rust value, and data2 is reserved for materialization.
impl_len_cow!(RLogical);
impl_altlogical_native_slice!(Cow<'static, [RLogical]>);
impl_dataptr_cow!(RLogical => i32);
impl_serialize!(Cow<'static, [RLogical]>, Vec<RLogical>, Cow::Owned);

impl_len_cow!(i32);
impl_altinteger_slice!(Cow<'static, [i32]>);
impl_dataptr_cow!(i32);
impl_serialize!(Cow<'static, [i32]>, Vec<i32>, Cow::Owned);

impl_len_cow!(f64);
impl_altreal_slice!(Cow<'static, [f64]>);
impl_dataptr_cow!(f64);
impl_serialize!(Cow<'static, [f64]>, Vec<f64>, Cow::Owned);

impl_len_cow!(u8);
impl_altraw_slice!(Cow<'static, [u8]>);
impl_dataptr_cow!(u8);
impl_serialize!(Cow<'static, [u8]>, Vec<u8>, Cow::Owned);

impl_len_cow!(Rcomplex);
impl_altcomplex_slice!(Cow<'static, [Rcomplex]>);
impl_dataptr_cow!(Rcomplex);
impl_serialize!(Cow<'static, [Rcomplex]>, Vec<Rcomplex>, Cow::Owned);
// endregion

// region: Low-level ALTREP trait implementations
//
// The low-level trait impls (Altrep, AltVec, Alt*, InferBase) for builtin types
// are located in altrep_impl.rs. This is because the impl_alt*_from_data! macros
// are defined there and need to be in the same module.
//
// See altrep_impl.rs for:
// - Vec<i32>, Vec<f64>, Vec<bool>, Vec<u8>, Vec<String>, Vec<Rcomplex>
// - Box<[i32]>, Box<[f64]>, Box<[bool]>, Box<[u8]>, Box<[String]>, Box<[Rcomplex]>
// - Cow<'static, [i32]>, Cow<'static, [f64]>, Cow<'static, [u8]>, Cow<'static, [Rcomplex]>
// - Range<i32>, Range<i64>, Range<f64>
// endregion

#[cfg(test)]
mod tests {
    use super::*;
    use crate::altrep_data::AltRealData;
    use crate::altrep_traits::NA_REAL;

    /// `NA_real_ * 1` as R computes it: arithmetic quiets the NaN, so the
    /// high word differs from `NA_REAL`'s while the low word stays 1954.
    const COMPUTED_NA: f64 = f64::from_bits(0x7FF8_0000_0000_07A2);

    // region: NA_REAL bit pattern tests

    /// Verify NA_REAL has the expected R bit pattern.
    #[test]
    fn na_real_bit_pattern() {
        assert_eq!(NA_REAL.to_bits(), 0x7FF0_0000_0000_07A2);
    }

    /// Regular NaN is NOT the same bit pattern as NA_real_.
    #[test]
    fn nan_is_not_na_real() {
        let nan = f64::NAN;
        assert!(nan.is_nan());
        assert_ne!(nan.to_bits(), NA_REAL.to_bits());
    }

    // endregion

    // region: Vec<f64> no_na — NA vs NaN

    /// A vector holding a regular NaN reports no_na = Some(false): R's
    /// `anyNA()` trusts the hint and counts NaN as missing (`ISNAN`).
    #[test]
    fn vec_f64_no_na_with_regular_nan_is_false() {
        let v: Vec<f64> = vec![1.0, f64::NAN, 3.0];
        assert_eq!(AltRealData::no_na(&v), Some(false));
    }

    /// A computed NA (`NA_real_ * 1` quiets the NaN) is still NA.
    #[test]
    fn vec_f64_no_na_with_computed_na_is_false() {
        let v: Vec<f64> = vec![1.0, COMPUTED_NA, 3.0];
        assert_eq!(AltRealData::no_na(&v), Some(false));
    }

    /// A vector containing NA_real_ should report no_na = Some(false).
    #[test]
    fn vec_f64_no_na_with_na_real_is_false() {
        let v: Vec<f64> = vec![1.0, NA_REAL, 3.0];
        assert_eq!(AltRealData::no_na(&v), Some(false));
    }

    /// A vector with no NaN and no NA should report no_na = Some(true).
    #[test]
    fn vec_f64_no_na_all_finite_is_true() {
        let v: Vec<f64> = vec![1.0, 2.0, 3.0];
        assert_eq!(AltRealData::no_na(&v), Some(true));
    }

    // endregion

    // region: Vec<f64> sum — NA vs NaN

    /// sum with na_rm=false and NA_real_ present should return Some(NA_REAL).
    #[test]
    fn vec_f64_sum_na_propagates() {
        let v: Vec<f64> = vec![1.0, NA_REAL, 3.0];
        let result = AltRealData::sum(&v, false);
        assert!(result.is_some());
        let bits = result.unwrap().to_bits();
        assert_eq!(
            bits,
            NA_REAL.to_bits(),
            "sum with NA should return NA_real_"
        );
    }

    /// sum with na_rm=true and NA_real_ present should skip the NA and sum the rest.
    #[test]
    fn vec_f64_sum_na_rm_skips_na() {
        let v: Vec<f64> = vec![1.0, NA_REAL, 3.0];
        let result = AltRealData::sum(&v, true);
        assert_eq!(result, Some(4.0));
    }

    /// sum with na_rm=false and regular NaN present should return Some(NaN) — NOT NA.
    #[test]
    fn vec_f64_sum_nan_propagates_as_nan_not_na() {
        let v: Vec<f64> = vec![1.0, f64::NAN, 3.0];
        let result = AltRealData::sum(&v, false);
        assert!(result.is_some());
        let val = result.unwrap();
        assert!(val.is_nan(), "sum with NaN (not NA) should return NaN");
        assert_ne!(
            val.to_bits(),
            NA_REAL.to_bits(),
            "sum with regular NaN should NOT return NA_real_"
        );
    }

    /// sum with na_rm=true and regular NaN present should skip the NaN.
    #[test]
    fn vec_f64_sum_nan_rm_skips_nan() {
        let v: Vec<f64> = vec![1.0, f64::NAN, 3.0];
        let result = AltRealData::sum(&v, true);
        assert_eq!(result, Some(4.0));
    }

    /// A computed NA propagates as NA (not NaN) and is skipped by na_rm.
    #[test]
    fn vec_f64_sum_computed_na() {
        let v: Vec<f64> = vec![1.0, COMPUTED_NA, 3.0];
        let na = AltRealData::sum(&v, false).expect("sum is always computed");
        assert!(na.is_na(), "{:#x}", na.to_bits());
        assert_eq!(AltRealData::sum(&v, true), Some(4.0));
    }

    /// NA wins over NaN whatever the order, as in R's `rmin` / `rmax`.
    #[test]
    fn vec_f64_min_max_na_trumps_nan() {
        for v in [
            vec![f64::NAN, 1.0, COMPUTED_NA],
            vec![COMPUTED_NA, f64::NAN, 1.0],
            vec![1.0, f64::NAN, NA_REAL],
        ] {
            for extreme in [
                AltRealData::min(&v, false),
                AltRealData::max(&v, false),
                AltRealData::sum(&v, false),
            ] {
                let value = extreme.expect("missing values give a result");
                assert!(value.is_na(), "{v:?} gave {:#x}", value.to_bits());
            }
            assert_eq!(AltRealData::min(&v, true), Some(1.0));
            assert_eq!(AltRealData::max(&v, true), Some(1.0));
        }
        let nan_only = vec![3.0, f64::NAN, 1.0];
        let min = AltRealData::min(&nan_only, false).expect("NaN gives a result");
        assert!(min.is_nan() && !min.is_na());
        assert_eq!(AltRealData::min(&nan_only, true), Some(1.0));
        assert_eq!(AltRealData::max(&nan_only, true), Some(3.0));
        let all_missing = vec![NA_REAL, f64::NAN];
        assert_eq!(AltRealData::min(&all_missing, true), None);
    }

    // endregion

    // region: Box<[f64]> no_na — NA vs NaN

    #[test]
    fn box_f64_no_na_with_regular_nan_is_false() {
        let v: Box<[f64]> = vec![1.0, f64::NAN, 3.0].into_boxed_slice();
        assert_eq!(AltRealData::no_na(&v), Some(false));
    }

    #[test]
    fn box_f64_no_na_with_na_real_is_false() {
        let v: Box<[f64]> = vec![1.0, NA_REAL, 3.0].into_boxed_slice();
        assert_eq!(AltRealData::no_na(&v), Some(false));
    }

    // endregion

    // region: &[f64] no_na — NA vs NaN

    #[test]
    fn slice_f64_no_na_with_regular_nan_is_false() {
        let data: &[f64] = &[1.0, f64::NAN, 3.0];
        assert_eq!(AltRealData::no_na(&data), Some(false));
    }

    #[test]
    fn slice_f64_no_na_with_na_real_is_false() {
        let data: &[f64] = &[1.0, NA_REAL, 3.0];
        assert_eq!(AltRealData::no_na(&data), Some(false));
    }

    // endregion

    // region: [f64; N] no_na — NA vs NaN

    #[test]
    fn array_f64_no_na_with_regular_nan_is_false() {
        let arr: [f64; 3] = [1.0, f64::NAN, 3.0];
        assert_eq!(AltRealData::no_na(&arr), Some(false));
    }

    #[test]
    fn array_f64_no_na_with_na_real_is_false() {
        let arr: [f64; 3] = [1.0, NA_REAL, 3.0];
        assert_eq!(AltRealData::no_na(&arr), Some(false));
    }

    // endregion

    // region: Cow<'static, [f64]> no_na — NA vs NaN

    #[test]
    fn cow_f64_no_na_with_regular_nan_is_false() {
        let v: Cow<'static, [f64]> = Cow::Owned(vec![1.0, f64::NAN, 3.0]);
        assert_eq!(AltRealData::no_na(&v), Some(false));
    }

    #[test]
    fn cow_f64_no_na_with_na_real_is_false() {
        let v: Cow<'static, [f64]> = Cow::Owned(vec![1.0, NA_REAL, 3.0]);
        assert_eq!(AltRealData::no_na(&v), Some(false));
    }

    // endregion
}