Struct LicenseValidator 

pub struct LicenseValidator { /* private fields */ }

License validator that checks keys against the API with caching.

The validator implements a multi-tier validation strategy:

1. Check key format (must start with sub_)
2. Check local cache for fresh result
3. Call API if cache is stale or missing
4. Fall back to stale cache if network fails

Examples

use logicaffeine_verify::LicenseValidator;

let validator = LicenseValidator::new();

// Validate a license key
match validator.validate("sub_abc123") {
    Ok(plan) => {
        if plan.can_verify() {
            println!("Verification enabled with {} plan", plan);
        }
    }
    Err(e) => eprintln!("License error: {}", e),
}

Implementations

impl LicenseValidator

pub fn new() -> Self

Create a new license validator.

The validator stores its cache in the system cache directory:

• macOS/Linux: ~/.cache/logos/verification_license.json
• Windows: %LOCALAPPDATA%\logos\verification_license.json

Examples

use logicaffeine_verify::LicenseValidator;

let validator = LicenseValidator::new();

pub fn validate(&self, key: &str) -> VerificationResult<LicensePlan>

Validate a license key.

Returns the license plan if valid and verification-capable. Returns an error if the key is invalid, the plan doesn’t include verification, or network validation fails.

Validation Steps

1. Format check: Key must start with sub_
2. Cache check: Return cached result if < 24 hours old
3. API call: Validate against api.logicaffeine.com
4. Fallback: Use stale cache if network fails

Errors

• LicenseInvalid - Key format is wrong or API rejected it
• LicenseInsufficientPlan - License valid but plan lacks verification

Examples

use logicaffeine_verify::LicenseValidator;

let validator = LicenseValidator::new();

// Invalid format
assert!(validator.validate("invalid").is_err());

// Valid key (requires network)
let result = validator.validate("sub_abc123");

Trait Implementations

impl Default for LicenseValidator

fn default() -> Self

Returns the “default value” for a type.