Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / src / query / predicates.lucb

## Composable, null-aware predicates; field values resolve at time zero.
import memory
import interop
import ownership
import query.scalars
from query.results import Row, copy_row
from storage import Buffer, List, text_copy, find_pair
from model import Element
from value import Value, ValueData
from animation import resolve_property
from codecs.common import find, starts
from path import valid_path, is_descendant, element_path, path_name
from types import invalid, limit_exceeded

pub enum Comparison as u8:
    equal = 0
    not_equal = 1
    less = 2
    less_equal = 3
    greater = 4
    greater_equal = 5

struct Rule:
    var operation: usize
    var comparison: Comparison
    var name: Buffer
    var text: Buffer
    var value: ValueData = ValueData()
    var left: usize
    var right: usize
    var callback: interop.Callback[interop.Reference[Row], bool]?

    func copy() -> Rule!:
        var result = Rule(operation = self.operation, comparison = self.comparison, left = self.left, right = self.right)
        errdefer result.close()
        result.name = try self.name.copy()
        result.text = try self.text.copy()
        result.value = try self.value.copy()
        if let callback = self.callback:
            result.callback = callback.clone()
        return result

    func close():
        self.name.close()
        self.text.close()
        self.value.close()
        if let callback = self.callback:
            callback.release()
        self.callback = none

pub struct Predicate:
    var rules: List[Rule]

    pub func init():
        self.rules = List[Rule]()

    pub func copy() -> Predicate!:
        var result = Predicate()
        errdefer result.close()
        try result.rules.reserve(self.rules.count)
        for rule in self.rules.span():
            try result.rules.push(try rule.copy())
        return result

    static func single(operation: usize, name: str, text: str = "") -> Predicate!:
        var result = Predicate()
        errdefer result.close()
        var rule = Rule(operation = operation)
        errdefer rule.close()
        rule.name = try text_copy(name)
        rule.text = try text_copy(text)
        try result.rules.push(rule)
        return result

    pub static func field(name: str, comparison: Comparison, value: interop.Reference[Value]) -> interop.Reference[Predicate]!:
        var result = try Predicate.single(1, name)
        errdefer result.close()
        result.rules.items[0].comparison = comparison
        result.rules.items[0].value = try (try value.get()).view_data().copy()
        let owned = result
        result = Predicate()
        return try own_predicate(owned)

    pub static func contains(name: str, text: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(2, name, text))

    pub static func starts_with(name: str, text: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(3, name, text))

    pub static func exists(name: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(4, name))

    pub static func is_null(name: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(5, name))

    pub static func by_type(name: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(6, name))

    pub static func under(path: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(7, path))

    pub static func name_is(name: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(8, name))

    pub static func has_metadata(name: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(9, name))

    pub static func metadata(name: str, text: str) -> interop.Reference[Predicate]!:
        return try own_predicate(try Predicate.single(10, name, text))

    pub static func custom(callback: interop.Callback[interop.Reference[Row], bool]) -> interop.Reference[Predicate]!:
        var result = try Predicate.single(14, "")
        result.rules.items[0].callback = callback.clone()
        return try own_predicate(result)

    func combined(other: const Predicate*, operation: usize) -> Predicate!:
        var result = try self.copy()
        errdefer result.close()
        if result.rules.count == 0:
            try result.rules.push(Rule())
        let left = result.rules.count - 1
        let offset = result.rules.count
        if other.rules.count == 0:
            try result.rules.push(Rule())
        else:
            try result.rules.reserve(result.rules.count + other.rules.count + 1)
            for source in other.rules.span():
                var rule = try source.copy()
                if rule.operation >= 11 and rule.operation <= 13:
                    rule.left += offset
                    rule.right += offset
                try result.rules.push(rule)
        let right = result.rules.count - 1
        try result.rules.push(Rule(operation = operation, left = left, right = right))
        return result

    pub func both(other: interop.Reference[Predicate]) -> interop.Reference[Predicate]!:
        return try own_predicate(try self.combined(try other.get(), 11))

    pub func either(other: interop.Reference[Predicate]) -> interop.Reference[Predicate]!:
        return try own_predicate(try self.combined(try other.get(), 12))

    pub func negate() -> interop.Reference[Predicate]!:
        var result = try self.copy()
        errdefer result.close()
        if result.rules.count == 0:
            try result.rules.push(Rule())
        try result.rules.push(Rule(operation = 13, left = result.rules.count - 1))
        let owned = result
        result = Predicate()
        return try own_predicate(owned)

    func evaluate(element: const Element*, index: usize, depth: usize) -> bool!:
        if depth > 128:
            error(limit_exceeded, "Prism predicate nesting exceeds 128")
        let rule = &self.rules.items[index]
        let op = rule.operation
        let name = rule.name.view()
        if op == 0:
            return true
        if op == 11:
            return try self.evaluate(element, rule.left, depth + 1) and try self.evaluate(element, rule.right, depth + 1)
        if op == 12:
            return try self.evaluate(element, rule.left, depth + 1) or try self.evaluate(element, rule.right, depth + 1)
        if op == 13:
            return not try self.evaluate(element, rule.left, depth + 1)
        if op == 14:
            let callback = rule.callback else error(invalid, "custom predicate callback is missing")
            let row = try copy_row(element)
            defer row.release()
            let result = callback.invoke(row)
            defer result.release()
            return try result.get()
        if op == 6:
            return element.kind.view() == name
        if op == 7:
            return valid_path(name) and element.path.view() != element_path(name) and is_descendant(element.path.view(), element_path(name))
        if op == 8:
            return path_name(element.path.view()) == name
        if op == 9:
            return find_pair(&element.metadata, name) != none
        if op == 10:
            let text = find_pair(&element.metadata, name) else return false
            return text == rule.text.view()
        let position = element.property(name)
        if op == 4:
            return position != none
        if op == 5:
            return position == none
        let property = position else return false
        var value = try resolve_property(&element.properties.items[property], 0.0)
        defer value.close()
        if op == 2 or op == 3:
            let text = scalars.string(&value) else return false
            return find(text, rule.text.view()) != none if op == 2 else starts(text, rule.text.view())
        if rule.comparison == Comparison.equal or rule.comparison == Comparison.not_equal:
            let equal = try scalars.equal(&value, &rule.value)
            return equal if rule.comparison == Comparison.equal else not equal
        let order = scalars.compare(&value, &rule.value) else return false
        if rule.comparison == Comparison.less:
            return order < 0
        if rule.comparison == Comparison.less_equal:
            return order <= 0
        if rule.comparison == Comparison.greater:
            return order > 0
        return order >= 0

    pub func accepts_row(element: const Element*) -> bool!:
        return true if self.rules.count == 0 else try self.evaluate(element, self.rules.count - 1, 0)

    ## Push the names of the properties whose values this predicate reads into
    ## `names`. A callback may read any property: then the answer is true and the
    ## caller treats every property as read.
    pub func reads(names: List[Buffer]*) -> bool!:
        for rule in self.rules.span():
            if rule.operation == 14:
                return true
            if rule.operation >= 1 and rule.operation <= 3:
                try names.push(try rule.name.copy())
        return false

    pub func has_callback() -> bool:
        for rule in self.rules.span():
            if rule.operation == 14:
                return true
        return false

    pub func close():
        for i in 0..<self.rules.count:
            self.rules.items[i].close()
        self.rules.close()

    pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
        for rule in self.rules.span():
            if let callback = rule.callback:
                callback.trace(visit, context)

pub let predicate_type = interop.Type[Predicate]("Prism predicate", Predicate.close, Predicate.trace, closeable = true)

pub func own_predicate(predicate: Predicate) -> interop.Reference[Predicate]!:
    var owned = predicate
    let native = new Predicate() in memory.heap catch failure:
        owned.close()
        error(failure.code, failure.message)
    native.rules = owned.rules
    return try interop.Reference[Predicate].adopt(native, predicate_type, memory.heap)