Enum `ErrorKind`

enum ErrorKind

The kind of an error (non-exhaustive)

Variants

Msg(String)

Generic error

CircularExtend { tpl: String, inheritance_chain: Vec<String> }

A loop was found while looking up the inheritance chain

MissingParent { current: String, parent: String }

A template is extending a template that wasn't found in the Tera instance

TemplateNotFound(String)

A template was missing (more generic version of MissingParent)

FilterNotFound(String)

A filter wasn't found

TestNotFound(String)

A test wasn't found

InvalidMacroDefinition(String)

A macro was defined in the middle of a template

FunctionNotFound(String)

A function wasn't found

Json(serde_json::Error)

An error happened while serializing JSON

CallFunction(String)

An error occured while executing a function.

CallFilter(String)

An error occured while executing a filter.

CallTest(String)

An error occured while executing a test.

Io(std::io::ErrorKind)

An IO error occured

Utf8Conversion { context: String }

UTF-8 conversion error

This should not occur unless invalid UTF8 chars are rendered

Implementations

`impl Debug for ErrorKind`

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

`impl Freeze for ErrorKind`

`impl RefUnwindSafe for ErrorKind`

`impl Send for ErrorKind`

`impl Sync for ErrorKind`

`impl Unpin for ErrorKind`

`impl UnsafeUnpin for ErrorKind`

`impl UnwindSafe for ErrorKind`

`impl<T> Any for ErrorKind`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for ErrorKind`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for ErrorKind`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> From for ErrorKind`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Pointable for ErrorKind`

unsafe fn init(init: <T as Pointable>::Init) -> usize
unsafe fn deref<'a>(ptr: usize) -> &'a T
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
unsafe fn drop(ptr: usize)

`impl<T, U> Into for ErrorKind`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for ErrorKind`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for ErrorKind`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>

`impl<V, T> VZip for ErrorKind`

fn vzip(self: Self) -> V