Struct ModelQuery 

pub struct ModelQuery<'a> { /* private fields */ }

Query builder for SAMM Aspect Models

Provides a fluent API for querying and analyzing SAMM models.

Implementations

impl<'a> ModelQuery<'a>

pub fn new(aspect: &'a Aspect) -> Self

Creates a new query builder for the given aspect

Examples

use oxirs_samm::query::ModelQuery;
let query = ModelQuery::new(aspect);

pub fn find_properties_with_collection_characteristic(&self) -> Vec<&Property>

Finds all properties with Collection, List, Set, or SortedSet characteristics

Returns

Vector of properties that have collection-type characteristics

pub fn find_optional_properties(&self) -> Vec<&Property>

Finds all optional properties

Returns

Vector of properties marked as optional

pub fn find_required_properties(&self) -> Vec<&Property>

Finds all required (non-optional) properties

Returns

Vector of properties that are required

pub fn find_properties_in_namespace(&self, namespace: &str) -> Vec<&Property>

Finds properties by URN namespace

Arguments

• namespace - The URN namespace to match (e.g., “urn:samm:org.example:1.0.0”)

Returns

Vector of properties in the specified namespace

pub fn find_properties_by_characteristic<F>( &self, predicate: F, ) -> Vec<&Property>

where F: Fn(&CharacteristicKind) -> bool,

Finds all properties with specific characteristic type

Arguments

• predicate - Function to test characteristic kind

Returns

Vector of properties matching the predicate

pub fn find_all_referenced_entities(&self) -> HashSet<String>

Finds all entities referenced directly or indirectly by the aspect

This performs a breadth-first search through all properties and their characteristics to discover all entity references.

Returns

Set of unique entity URNs referenced by the model

pub fn build_dependency_graph(&self) -> Vec<Dependency>

Builds a dependency graph of all model elements

Returns

Vector of dependencies showing relationships between elements

pub fn detect_circular_dependencies(&self) -> Vec<Vec<String>>

Detects circular dependencies in the model

Uses depth-first search to detect cycles in the dependency graph.

Returns

Vector of URN chains representing circular dependencies

pub fn complexity_metrics(&self) -> ComplexityMetrics

Calculates complexity metrics for the model

Returns

Complexity metrics including property counts, nesting depth, and reference counts

pub fn find_properties_by_name_pattern(&self, pattern: &str) -> Vec<&Property>

Finds properties by name pattern (case-insensitive)

Arguments

• pattern - Pattern to match against property names

Returns

Vector of properties with names containing the pattern

pub fn group_properties_by_characteristic_type( &self, ) -> HashMap<String, Vec<&Property>>

Groups properties by their characteristic type

Returns

HashMap mapping characteristic type names to vectors of properties

pub fn aspect(&self) -> &Aspect

Gets the aspect reference

pub fn fuzzy_find_properties( &self, query: &str, max_distance: usize, ) -> Vec<(&Property, usize)>

Find properties by fuzzy name matching

Uses Levenshtein distance to find properties whose names are similar to the query. Useful for finding properties when you don’t know the exact name.

Arguments

• query - The property name to search for (partial or misspelled)
• max_distance - Maximum Levenshtein distance (lower = stricter matching)

Returns

Vector of (property, distance) tuples, sorted by distance (best matches first)

Examples

use oxirs_samm::query::ModelQuery;
let query = ModelQuery::new(aspect);

// Find properties with names similar to "temperture" (misspelled)
let results = query.fuzzy_find_properties("temperture", 3);
for (property, distance) in results {
    println!("Found: {} (distance: {})", property.name(), distance);
}

pub fn fuzzy_find_operations( &self, query: &str, max_distance: usize, ) -> Vec<(&Operation, usize)>

Find operations by fuzzy name matching

Uses Levenshtein distance to find operations whose names are similar to the query.

Arguments

• query - The operation name to search for
• max_distance - Maximum Levenshtein distance

Returns

Vector of (operation, distance) tuples, sorted by distance

pub fn fuzzy_find_any_element( &self, query: &str, max_distance: usize, ) -> Vec<(String, String, usize)>

Find all model elements (properties, operations) by fuzzy search

Searches across all element names in the aspect.

Arguments

• query - The element name to search for
• max_distance - Maximum Levenshtein distance

Returns

Vector of (element name, URN, distance) tuples, sorted by distance

pub fn suggest_properties(&self, prefix: &str, limit: usize) -> Vec<String>

Find properties with similar names (auto-suggest)

Provides auto-complete style suggestions based on prefix matching combined with fuzzy matching as fallback.

Arguments

• prefix - The partial property name to match
• limit - Maximum number of suggestions to return

Returns

Vector of suggested property names