Struct Validator 

pub struct Validator { /* private fields */ }

Main data validator with comprehensive validation capabilities

Implementations

impl Validator

pub fn new(config: ValidationConfig) -> Result<Self, CoreError>

Create a new validator with configuration

Arguments

• config - Validation configuration settings

Returns

A new Validator instance or an error if initialization fails

Example

use scirs2_core::validation::data::{Validator, ValidationConfig};

let mut config = ValidationConfig::default();
config.max_depth = 10;
config.strict_mode = true;

let validator = Validator::new(config)?;

pub fn validate( &self, data: &JsonValue, schema: &ValidationSchema, ) -> Result<ValidationResult, CoreError>

Validate JSON data against a schema

This method performs comprehensive validation of JSON data against a predefined schema, including type checking, constraint validation, and custom rules.

Arguments

• data - The JSON data to validate
• schema - The validation schema to apply

Returns

A ValidationResult containing the validation outcome and any errors/warnings

Example

use scirs2_core::validation::data::{Validator, ValidationSchema, DataType, Constraint, ValidationConfig};

let validator = Validator::new(ValidationConfig::default())?;

let schema = ValidationSchema::new()
    .require_field("email", DataType::String)
    .add_constraint("email", Constraint::Pattern("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$".to_string()));

let data = serde_json::json!({
    "email": "user@example.com"
});

let result = validator.validate(&data, &schema)?;
assert!(result.is_valid());

pub fn validate_ndarray<S, D>( &self, array: &ArrayBase<S, D>, constraints: &ArrayValidationConstraints, config: &ValidationConfig, ) -> Result<ValidationResult, CoreError>

where S: Data, D: Dimension, S::Elem: Float + Debug + Send + Sync + ScalarOperand + FromPrimitive,

Validate ndarray with comprehensive checks

Performs validation on scientific arrays including shape validation, numeric quality checks, statistical constraints, and performance characteristics.

Arguments

• array - The ndarray to validate
• constraints - Validation constraints to apply
• config - Validation configuration

Type Parameters

• S - Storage type (must implement Data)
• D - Dimension type
• S::Elem - Element type (must be a floating-point type)

Returns

A ValidationResult with detailed validation information

Example

use scirs2_core::validation::data::{Validator, ValidationConfig, ArrayValidationConstraints};
use ::ndarray::Array2;

let validator = Validator::new(ValidationConfig::default())?;

let data = Array2::from_shape_vec((3, 3), vec![
    1.0, 2.0, 3.0,
    4.0, 5.0, 6.0,
    7.0, 8.0, 9.0
])?;

let constraints = ArrayValidationConstraints::new()
    .withshape(vec![3, 3])
    .check_numeric_quality();

let result = validator.validate_ndarray(&data, &constraints, &ValidationConfig::default())?;
assert!(result.is_valid());

pub fn generate_quality_report<S, D>( &self, array: &ArrayBase<S, D>, fieldname: &str, ) -> Result<DataQualityReport, CoreError>

where S: Data, D: Dimension, S::Elem: Float + Debug + ScalarOperand + Send + Sync + FromPrimitive,

Generate comprehensive data quality report

Analyzes an array and generates a detailed quality report including completeness, accuracy, consistency, and statistical properties.

Arguments

• array - The array to analyze
• fieldname - Name of the field for reporting

Returns

A DataQualityReport with quality metrics and recommendations

Example

use scirs2_core::validation::data::{Validator, ValidationConfig};
use ::ndarray::Array1;

let validator = Validator::new(ValidationConfig::default())?;

let data = Array1::from_vec(vec![1.0, 2.0, 3.0, 4.0, 5.0]);
let report = validator.generate_quality_report(&data, "measurements")?;

println!("Quality score: {}", report.quality_score);
println!("Completeness: {}", report.metrics.completeness);

pub fn add_custom_rule( &mut self, name: String, rule: Box<dyn ValidationRule + Send + Sync>, )

Add a custom validation rule

Registers a custom validation rule that can be referenced in schemas.

Arguments

• name - Unique name for the rule
• rule - The validation rule implementation

Example

use scirs2_core::validation::data::{Validator, ValidationConfig, ValidationRule};
use serde_json::Value as JsonValue;

struct EmailRule;

impl ValidationRule for EmailRule {
    fn validate(&self, value: &JsonValue, fieldpath: &str) -> Result<(), String> {
        if let Some(email) = value.as_str() {
            if email.contains('@') {
                Ok(())
            } else {
                Err(format!("{fieldpath}: invalid email format"))
            }
        } else {
            Err(format!("{fieldpath}: expected string"))
        }
    }

    fn name(&self) -> &str { "email" }
    fn description(&self) -> &str { "Validates email format" }
}

let mut validator = Validator::new(ValidationConfig::default())?;
validator.add_custom_rule("email".to_string(), Box::new(EmailRule));

pub fn clear_cache(&self) -> Result<(), CoreError>

Clear validation cache

pub fn get_cache_stats(&self) -> Result<(usize, f64), CoreError>

Get cache statistics

Trait Implementations

impl Default for Validator

fn default() -> Self

Returns the “default value” for a type.