oxirs-rule 0.2.4

Forward/backward rule engine for RDFS, OWL, and SWRL reasoning
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

//! SWRL (Semantic Web Rule Language) - Core Types
//!
//! This module implements SWRL rule components.

use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// SWRL atom types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum SwrlAtom {
    /// Class atom: C(x)
    Class {
        class_predicate: String,
        argument: SwrlArgument,
    },
    /// Individual property atom: P(x, y)
    IndividualProperty {
        property_predicate: String,
        argument1: SwrlArgument,
        argument2: SwrlArgument,
    },
    /// Datavalue property atom: P(x, v)
    DatavalueProperty {
        property_predicate: String,
        argument1: SwrlArgument,
        argument2: SwrlArgument,
    },
    /// Built-in atom: builtin(args...)
    Builtin {
        builtin_predicate: String,
        arguments: Vec<SwrlArgument>,
    },
    /// Same individual atom: sameAs(x, y)
    SameIndividual {
        argument1: SwrlArgument,
        argument2: SwrlArgument,
    },
    /// Different individuals atom: differentFrom(x, y)
    DifferentIndividuals {
        argument1: SwrlArgument,
        argument2: SwrlArgument,
    },
}

/// SWRL argument types
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum SwrlArgument {
    /// Variable
    Variable(String),
    /// Individual
    Individual(String),
    /// Literal value
    Literal(String),
}

/// SWRL rule structure
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SwrlRule {
    /// Rule identifier
    pub id: String,
    /// Rule body (antecedent)
    pub body: Vec<SwrlAtom>,
    /// Rule head (consequent)
    pub head: Vec<SwrlAtom>,
    /// Rule metadata
    pub metadata: HashMap<String, String>,
}

/// Built-in function definition
#[derive(Debug, Clone)]
pub struct BuiltinFunction {
    /// Function name
    pub name: String,
    /// Function namespace
    pub namespace: String,
    /// Minimum number of arguments
    pub min_args: usize,
    /// Maximum number of arguments (None for unlimited)
    pub max_args: Option<usize>,
    /// Function implementation
    pub implementation: fn(&[SwrlArgument]) -> Result<bool>,
}

/// SWRL execution context
#[derive(Debug, Clone, Default)]
pub struct SwrlContext {
    /// Variable bindings
    pub bindings: HashMap<String, SwrlArgument>,
    /// Execution trace
    pub trace: Vec<String>,
}