Struct ValidationResult 

pub struct ValidationResult {
    pub valid: bool,
    pub errors: Vec<String>,
    pub warnings: Vec<String>,
}

Validation result with error details.

Uses a builder pattern: start with ValidationResult::ok(), then chain with_error() and with_warning() calls.

Example

use netspeed_cli::config::ValidationResult;

// Start valid, then add issues via builder chaining
let result = ValidationResult::ok()
    .with_warning("deprecated option")
    .with_error("invalid profile");

assert!(!result.valid);          // errors flip valid to false
assert_eq!(result.errors.len(), 1);
assert_eq!(result.warnings.len(), 1);

Fields

valid: bool

Whether validation passed (no errors). Warnings do not affect this.

errors: Vec<String>

Error messages (any error sets valid to false).

warnings: Vec<String>

Warning messages (do not affect valid).

Implementations

impl ValidationResult

pub fn ok() -> Self

Create a successful validation result.

Example

use netspeed_cli::config::ValidationResult;

let result = ValidationResult::ok();
assert!(result.valid);
assert!(result.errors.is_empty());
assert!(result.warnings.is_empty());

pub fn with_warning(self, warning: impl Into<String>) -> Self

Add a warning to the result.

Warnings do not change valid — the result remains passable even with warnings.

Example

use netspeed_cli::config::ValidationResult;

// Warnings preserve valid=true
let result = ValidationResult::ok().with_warning("'simple' is deprecated");
assert!(result.valid);
assert_eq!(result.warnings.len(), 1);
assert!(result.warnings[0].contains("deprecated"));

// Multiple warnings can be chained
let result = ValidationResult::ok()
    .with_warning("first warning")
    .with_warning("second warning");
assert!(result.valid);
assert_eq!(result.warnings.len(), 2);

pub fn error(msg: impl Into<String>) -> Self

Create a validation failure.

Example

use netspeed_cli::config::ValidationResult;

let result = ValidationResult::error("invalid profile 'foo'");
assert!(!result.valid);
assert_eq!(result.errors.len(), 1);
assert!(result.errors[0].contains("foo"));
assert!(result.warnings.is_empty());

pub fn with_error(self, error: impl Into<String>) -> Self

Add an error to the result.

Unlike with_warning(), this flips valid to false.

Example

use netspeed_cli::config::ValidationResult;

// Adding an error flips valid to false
let result = ValidationResult::ok().with_error("bad theme");
assert!(!result.valid);
assert_eq!(result.errors.len(), 1);

// Multiple errors accumulate
let result = ValidationResult::error("first error")
    .with_error("second error");
assert!(!result.valid);
assert_eq!(result.errors.len(), 2);

// Errors and warnings can be mixed — errors always flip valid
let result = ValidationResult::ok()
    .with_warning("just a heads-up")
    .with_error("actual problem");
assert!(!result.valid);
assert_eq!(result.warnings.len(), 1);
assert_eq!(result.errors.len(), 1);

pub fn merge(self, other: ValidationResult) -> Self

Merge another validation result into this one.

Combines both error and warning lists. If the other result is invalid, this result also becomes invalid.

Example

use netspeed_cli::config::ValidationResult;

// Merging two valid results stays valid
let a = ValidationResult::ok().with_warning("warn-a");
let b = ValidationResult::ok().with_warning("warn-b");
let merged = a.merge(b);
assert!(merged.valid);
assert_eq!(merged.warnings.len(), 2);

// Merging an invalid result makes the whole thing invalid
let a = ValidationResult::ok();
let b = ValidationResult::error("bad profile");
let merged = a.merge(b);
assert!(!merged.valid);
assert_eq!(merged.errors.len(), 1);

// Both errors and warnings are accumulated
let a = ValidationResult::error("error-a").with_warning("warn-a");
let b = ValidationResult::error("error-b").with_warning("warn-b");
let merged = a.merge(b);
assert!(!merged.valid);
assert_eq!(merged.errors.len(), 2);
assert_eq!(merged.warnings.len(), 2);

Trait Implementations

impl Clone for ValidationResult

fn clone(&self) -> ValidationResult

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ValidationResult

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.