path: root/src/errors.rs

// Copyright (C) 2021, 2022, 2023 Soni L.
// SPDX-License-Identifier: MIT OR Apache-2.0

//! <!-- TODO figure out module-level docs for this -->

// #[cfg(doc)]
// use crate::PatternTypes;

/// These are errors that may be returned by the pattern compiler when
/// compiling a pattern.
///
/// "String" here refers to a string literal in the pattern, not the input
/// string. The input string is referred to as "the pattern".
#[derive(Debug)]
#[non_exhaustive]
pub enum PatternError<'a> {
    // Syntax Errors:

    /// The pattern contains an invalid string escape.
    StringEscape(usize, &'a str),
    /// The pattern ends in the middle of a string literal.
    StringEnd(usize, &'a str),
    /// The pattern contains an invalid regex escape.
    RegexEscape(usize, &'a str),
    /// The pattern ends in the middle of a regex literal.
    RegexEnd(usize, &'a str),
    /// The pattern contains characters that don't make up a token.
    Token(usize, &'a str),

    // Link Errors:

    /// The pattern requests a parameter that wasn't provided.
    UnknownParameter(usize, &'a str),
    /// The pattern requests a predicate that wasn't provided.
    UnknownPredicate(usize, &'a str),
    /// The pattern contains an invalid regex.
    Regex(usize, &'a str, ::regex::Error),

    // Extra Errors:

    /// The pattern contains a token which has not yet been implemented.
    Unimplemented(usize, &'a str),
}

/// These are errors that may be returned by the matcher when matching a
/// pattern.
// #[derive(Clone, Debug)]
#[derive(Debug)]
#[non_exhaustive]
pub enum MatchError {
     /// Returned if the pattern nests too deeply.
     StackOverflow,
     /// Returned if the pattern rejects the input.
     ValidationError,
     /// Returned if the pattern contains conflicting/unsatisfiable type
     /// requirements.
     Unsatisfiable,
}

/// Error returned while unwrapping a `Graph`.
#[derive(Debug)]
#[non_exhaustive]
pub enum UnpackError {
     /// Returned if the deserialization recurses too deeply.
    StackOverflow,
    /// Returned if there's nothing to deserialize.
    Empty,
    /// The packed data is incompatible with the data structure.
    Unsatisfiable,
    /// Wrapped Serde error.
    Serde(serde::de::value::Error),
}

impl std::fmt::Display for UnpackError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::StackOverflow => write!(f, "stack overflow"),
            Self::Empty => write!(f, "no results"),
            Self::Unsatisfiable => write!(f, "unsatisfiable"),
            Self::Serde(e) => e.fmt(f),
        }
    }
}

impl std::error::Error for UnpackError {
}

impl serde::de::Error for UnpackError {
    fn custom<T>(msg: T) -> Self where T: std::fmt::Display {
        Self::Serde(serde::de::value::Error::custom(msg))
    }
}