Struct traceback_error::TracebackError

pub struct TracebackError {
    pub message: String,
    pub file: String,
    pub line: u32,
    pub parent: Option<Box<TracebackError>>,
    pub time_created: DateTime<Utc>,
    pub extra_data: Value,
    pub project: Option<String>,
    pub computer: Option<String>,
    pub user: Option<String>,
    pub is_parent: bool,
    pub is_handled: bool,
    /* private fields */
}

Fields

message: String

file: String

line: u32

parent: Option<Box<TracebackError>>

time_created: DateTime<Utc>

extra_data: Value

project: Option<String>

computer: Option<String>

user: Option<String>

is_parent: bool

is_handled: bool

Implementations

impl TracebackError

Cloning this may be expensive, but for now it’s fine The reason it may be expensive is because it recursively clones the parent and the parent’s parent and so on (i think) To fix this, we could make it so that each of the with_ functions consume self, and then return a new Self with the new data Very easy fix, but i am unsure if we’ll need the possibility to keep the old error Maybe make non-consuming and consuming versions?

pub fn new(message: String, file: String, line: u32) -> Self

pub fn with_parent(self, parent: TracebackError) -> Self

pub fn with_extra_data(self, extra_data: Value) -> Self

pub fn with_project(self, project: &str) -> Self

pub fn with_computer_name(self, computer: &str) -> Self

pub fn with_username(self, user: &str) -> Self

pub fn with_env_vars(self) -> Self

pub fn with_is_parent(self, is_parent: bool) -> Self

pub fn clone(&mut self) -> Self

Trait Implementations

impl Clone for TracebackError

fn clone(&self) -> TracebackError

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TracebackError

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

Formats the value using the given formatter.

impl Default for TracebackError

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TracebackError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TracebackError

This display implementation is recursive, and will print the error and all its parents with a tab in front of each parent.

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

Formats the value using the given formatter.

impl Drop for TracebackError

fn drop(&mut self)

Executes the destructor for this type.

impl Error for TracebackError

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type based access to context intended for error reports.

impl Error for TracebackError

fn custom<T: Display>(msg: T) -> Self

Raised when there is general error when deserializing a type.

fn invalid_type(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self

Raised when a Deserialize receives a type different from what it was expecting.

fn invalid_value(unexp: Unexpected<'_>, exp: &dyn Expected) -> Self

Raised when a Deserialize receives a value of the right type but that is wrong for some other reason.

fn invalid_length(len: usize, exp: &dyn Expected) -> Self

Raised when deserializing a sequence or map and the input data contains too many or too few elements.

fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self

Raised when a Deserialize enum type received a variant with an unrecognized name.

fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self

Raised when a Deserialize struct type received a field with an unrecognized name.

fn missing_field(field: &'static str) -> Self

Raised when a Deserialize struct type expected to receive a required field with a particular name but that field was not present in the input.

fn duplicate_field(field: &'static str) -> Self

Raised when a Deserialize struct type received more than one of the same field.

impl PartialEq<TracebackError> for TracebackError

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TracebackError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.