sveppa-bencode 0.2.2

use std::{
    any::type_name,
    num::ParseIntError,
    string::FromUtf8Error,
};

#[derive(Debug)]
/// Possible error values when parsing a bencode struct into a value, or utf8 bytes into a
/// bencode struct.
pub enum BencodeParserError {
    /// When you call an enum destructuring method on the wrong variant.
    /// Contains a message with invalid type and which method it was passed to.
    ///
    /// eg: calling `as_int()` on `Bencode::List`, or `as_list()` on `Bencode::Dict`, etc.
    InvalidVariantMethod(String),
    /// An invalid UTF8 byte sequence was found when calling `as_usize()` or `as_string()`.
    ///
    /// eg: some byte outside of the standard ASCII range.
    InvalidUTF8String(FromUtf8Error),
    /// An invalid ASCII byte was found when calling `as_usize()`.
    ///
    /// See: `ParseIntError` on `usize::from_str_radix()`
    InvalidASCIIInteger(ParseIntError),
    /// Indicates an expected 'e' was missing. All bencode types except ByteStr expect an 'e' byte
    /// after data to indicate the end of the object.
    MissingSentinel,
    /// Indicates that the bytes passed to a parse function are not valid ASCII.
    InvalidASCIIBytes,
    /// Indicates that bytes passed to a parse function were valid ascii, but could not be parsed to
    /// an integer. (in cases like bytestr length, or an integer value.)
    InvalidIntegerString,
    /// Indicates that the length specified by a bytestring is longer than the remaining number of
    /// bytes passed into the parse function.
    ByteStringLengthOverflow,
    /// Indicates that while parsing a dictionary object, a non bytestring key was found.
    BadDictionaryKey,
    /// when a character is encountered by the parse_child function, that is not applicable to any
    /// of the bencode types.
    NotAValidBencodeByte,
    /// Indicates that the first byte of the array passed to a parsing function was not valid.
    ///
    /// eg: as_int where first byte is not 'i', as_bstr where the first byte is not [0-9], etc.
    BadFirstByte,
}

/// create an InvalidVariantMethod error easily.
pub(crate) fn invalid_variant_method<T>(method: &'static str, _type_obj: T) -> BencodeParserError {
    BencodeParserError::InvalidVariantMethod(
        format!("{} passed to {}", type_name::<T>(), method)
    )
}