views.nct

//! Slice view operations and iteration adapters.

include ./index.nct

use std/ptr.from_addr

func values_equal<T>(left: &T, right: &T): bool where (&T == &T): bool {
    return left == right
}

func value_is_less<T>(left: &T, right: &T): bool where (&T < &T): bool {
    return left < right
}

instance [T] {
    method &self.len(): usize {
        return slice_len_raw(self)
    }

    method &self.is_empty(): bool {
        return slice_len_raw(self) == 0
    }

    method &self.ptr(): *T {
        return from_addr(slice_ptr_addr_raw(self))
    }

    method &self.get(index: usize): &T? {
        if index >= self.len() {
            return none
        }
        return &self[index]
    }

    method &+self.get_mut(index: usize): &+T? {
        if index >= self.len() {
            return none
        }
        return &+self[index]
    }

    method &self.first(): &T? {
        return self.get(0)?
    }

    operator (&self == other: &Self): bool where (&T == &T): bool {
        if self.len() != other.len() {
            return false
        }
        var index: usize = 0
        while index < self.len() {
            if !values_equal(&self[index], &other[index]) {
                return false
            }
            index = index + 1
        }
        return true
    }

    method &self.contains(expected: &T): bool where (&T == &T): bool {
        let _index: usize = self.position(expected) otherwise { return false }
        return true
    }

    method &self.position(expected: &T): usize? where (&T == &T): bool {
        var index: usize = 0
        while index < self.len() {
            if values_equal(&self[index], expected) {
                return index
            }
            index = index + 1
        }
        return none
    }

    operator (&self < other: &Self): bool where (&T < &T): bool {
        let shared_len: usize = if self.len() < other.len() { self.len() } else { other.len() }
        var index: usize = 0
        while index < shared_len {
            if value_is_less(&self[index], &other[index]) { return true }
            if value_is_less(&other[index], &self[index]) { return false }
            index = index + 1
        }
        return self.len() < other.len()
    }
}