Trait FromEure 

pub trait FromEure<'doc>: Sized {
    type Error;

    // Required method
    fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>;
}

Trait for parsing Rust types from Eure documents.

Types implementing this trait can be constructed from EureDocument via ParseContext.

Lifetime Parameter

The 'doc lifetime ties the parsed output to the document’s lifetime, allowing zero-copy parsing for reference types like &'doc str.

Examples

// Reference type - borrows from document
impl<'doc> FromEure<'doc> for &'doc str { ... }

// Owned type - no lifetime dependency
impl FromEure<'_> for String { ... }

Required Associated Types

type Error

The error type returned by parsing.

Required Methods

fn parse(ctx: &ParseContext<'doc>) -> Result<Self, Self::Error>

Parse a value of this type from the given parse context.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl FromEure<'_> for ParsedSchemaNodeContent

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<ParsedSchemaNodeContent, <ParsedSchemaNodeContent as FromEure<'_>>::Error>

impl FromEure<'_> for ParsedUnknownFieldsPolicy

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<ParsedUnknownFieldsPolicy, <ParsedUnknownFieldsPolicy as FromEure<'_>>::Error>

impl FromEure<'_> for bool

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<bool, <bool as FromEure<'_>>::Error>

impl FromEure<'_> for f32

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<f32, <f32 as FromEure<'_>>::Error>

impl FromEure<'_> for f64

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<f64, <f64 as FromEure<'_>>::Error>

impl FromEure<'_> for i32

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<i32, <i32 as FromEure<'_>>::Error>

impl FromEure<'_> for i64

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<i64, <i64 as FromEure<'_>>::Error>

impl FromEure<'_> for u32

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<u32, <u32 as FromEure<'_>>::Error>

impl FromEure<'_> for u64

type Error = ParseError

fn parse(ctx: &ParseContext<'_>) -> Result<u64, <u64 as FromEure<'_>>::Error>

impl FromEure<'_> for usize

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<usize, <usize as FromEure<'_>>::Error>

impl FromEure<'_> for String

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<String, <String as FromEure<'_>>::Error>

impl FromEure<'_> for EureConfig

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<EureConfig, <EureConfig as FromEure<'_>>::Error>

impl FromEure<'_> for ParsedRecordSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<ParsedRecordSchema, <ParsedRecordSchema as FromEure<'_>>::Error>

impl FromEure<'_> for ParsedSchemaNode

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<ParsedSchemaNode, <ParsedSchemaNode as FromEure<'_>>::Error>

impl FromEure<'_> for ParsedUnionSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<ParsedUnionSchema, <ParsedUnionSchema as FromEure<'_>>::Error>

impl FromEure<'_> for SchemaRef

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<SchemaRef, <SchemaRef as FromEure<'_>>::Error>

impl FromEure<'_> for TypeReference

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<TypeReference, <TypeReference as FromEure<'_>>::Error>

impl FromEure<'_> for BigInt

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<BigInt, <BigInt as FromEure<'_>>::Error>

impl FromEure<'_> for Regex

type Error = ParseError

fn parse( ctx: &ParseContext<'_>, ) -> Result<Regex, <Regex as FromEure<'_>>::Error>

impl<'doc> FromEure<'doc> for &'doc str

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<&'doc str, <&'doc str as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for BindingStyle

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<BindingStyle, <BindingStyle as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for Description

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<Description, <Description as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for ()

type Error = ParseError

fn parse(ctx: &ParseContext<'doc>) -> Result<(), <() as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for SecurityConfig

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<SecurityConfig, <SecurityConfig as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for Target

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<Target, <Target as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for ParsedArraySchema

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<ParsedArraySchema, <ParsedArraySchema as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for ParsedExtTypeSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<ParsedExtTypeSchema, <ParsedExtTypeSchema as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for ParsedFloatSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<ParsedFloatSchema, <ParsedFloatSchema as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for ParsedIntegerSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<ParsedIntegerSchema, <ParsedIntegerSchema as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for ParsedMapSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<ParsedMapSchema, <ParsedMapSchema as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for ParsedRecordFieldSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<ParsedRecordFieldSchema, <ParsedRecordFieldSchema as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for ParsedTupleSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<ParsedTupleSchema, <ParsedTupleSchema as FromEure<'doc>>::Error>

impl<'doc> FromEure<'doc> for TextSchema

type Error = ParseError

fn parse( ctx: &ParseContext<'doc>, ) -> Result<TextSchema, <TextSchema as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, Err> FromEure<'doc> for (A, B, C, D, E)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E), <(A, B, C, D, E) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, Err> FromEure<'doc> for (A, B, C, D, E, F)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F), <(A, B, C, D, E, F) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, Err> FromEure<'doc> for (A, B, C, D, E, F, G)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G), <(A, B, C, D, E, F, G) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H), <(A, B, C, D, E, F, G, H) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H, I), <(A, B, C, D, E, F, G, H, I) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H, I, J), <(A, B, C, D, E, F, G, H, I, J) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K), <(A, B, C, D, E, F, G, H, I, J, K) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L), <(A, B, C, D, E, F, G, H, I, J, K, L) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, M, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, M: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M), <(A, B, C, D, E, F, G, H, I, J, K, L, M) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, M, N, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, M: FromEure<'doc, Error = Err>, N: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N), <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, M: FromEure<'doc, Error = Err>, N: FromEure<'doc, Error = Err>, O: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O), <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Err> FromEure<'doc> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, F: FromEure<'doc, Error = Err>, G: FromEure<'doc, Error = Err>, H: FromEure<'doc, Error = Err>, I: FromEure<'doc, Error = Err>, J: FromEure<'doc, Error = Err>, K: FromEure<'doc, Error = Err>, L: FromEure<'doc, Error = Err>, M: FromEure<'doc, Error = Err>, N: FromEure<'doc, Error = Err>, O: FromEure<'doc, Error = Err>, P: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, D, Err> FromEure<'doc> for (A, B, C, D)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, D: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C, D), <(A, B, C, D) as FromEure<'doc>>::Error>

impl<'doc, A, B, C, Err> FromEure<'doc> for (A, B, C)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, C: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B, C), <(A, B, C) as FromEure<'doc>>::Error>

impl<'doc, A, B, Err> FromEure<'doc> for (A, B)

where A: FromEure<'doc, Error = Err>, B: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A, B), <(A, B) as FromEure<'doc>>::Error>

impl<'doc, A, Err> FromEure<'doc> for (A,)

where A: FromEure<'doc, Error = Err>, Err: From<ParseError>,

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<(A,), <(A,) as FromEure<'doc>>::Error>

impl<'doc, K, T> FromEure<'doc> for BTreeMap<K, T>

where K: ParseObjectKey<'doc>, T: FromEure<'doc>, <T as FromEure<'doc>>::Error: From<ParseError>,

type Error = <T as FromEure<'doc>>::Error

fn parse( ctx: &ParseContext<'doc>, ) -> Result<BTreeMap<K, T>, <BTreeMap<K, T> as FromEure<'doc>>::Error>

impl<'doc, K, T> FromEure<'doc> for HashMap<K, T>

where K: ParseObjectKey<'doc>, T: FromEure<'doc>, <T as FromEure<'doc>>::Error: From<ParseError>,

type Error = <T as FromEure<'doc>>::Error

fn parse( ctx: &ParseContext<'doc>, ) -> Result<HashMap<K, T>, <HashMap<K, T> as FromEure<'doc>>::Error>

impl<'doc, K, T> FromEure<'doc> for IndexMap<K, T>

where K: ParseObjectKey<'doc>, T: FromEure<'doc>, <T as FromEure<'doc>>::Error: From<ParseError>,

type Error = <T as FromEure<'doc>>::Error

fn parse( ctx: &ParseContext<'doc>, ) -> Result<IndexMap<K, T>, <IndexMap<K, T> as FromEure<'doc>>::Error>

impl<'doc, T> FromEure<'doc> for Option<T>

where T: FromEure<'doc>, <T as FromEure<'doc>>::Error: From<ParseError>,

Option<T> is a union with variants some and none.

• $variant: some -> parse T
• $variant: none -> None
• No $variant and value is null -> None
• No $variant and value is not null -> try parsing as T (Some)

type Error = <T as FromEure<'doc>>::Error

fn parse( ctx: &ParseContext<'doc>, ) -> Result<Option<T>, <Option<T> as FromEure<'doc>>::Error>

impl<'doc, T> FromEure<'doc> for Vec<T>

where T: FromEure<'doc>, <T as FromEure<'doc>>::Error: From<ParseError>,

type Error = <T as FromEure<'doc>>::Error

fn parse( ctx: &ParseContext<'doc>, ) -> Result<Vec<T>, <Vec<T> as FromEure<'doc>>::Error>

impl<'doc, T> FromEure<'doc> for IndexSet<T>

where T: FromEure<'doc> + Eq + Hash, <T as FromEure<'doc>>::Error: From<ParseError>,

type Error = <T as FromEure<'doc>>::Error

fn parse( ctx: &ParseContext<'doc>, ) -> Result<IndexSet<T>, <IndexSet<T> as FromEure<'doc>>::Error>

impl<'doc, T, E, Err> FromEure<'doc> for Result<T, E>

where T: FromEure<'doc, Error = Err>, E: FromEure<'doc, Error = Err>, Err: From<ParseError>,

Result<T, E> is a union with variants ok and err.

• $variant: ok -> parse T as Ok
• $variant: err -> parse E as Err
• No $variant -> try Ok first, then Err (priority-based)

type Error = Err

fn parse( ctx: &ParseContext<'doc>, ) -> Result<Result<T, E>, <Result<T, E> as FromEure<'doc>>::Error>

Implementors

impl FromEure<'_> for VariantRepr

type Error = ParseError

impl FromEure<'_> for PrimitiveValue

type Error = ParseError

impl FromEure<'_> for Identifier

type Error = ParseError

impl FromEure<'_> for Text

type Error = ParseError

impl<'doc> FromEure<'doc> for &'doc PrimitiveValue

type Error = ParseError

impl<'doc> FromEure<'doc> for &'doc NodeArray

type Error = ParseError

impl<'doc> FromEure<'doc> for EureDocument

type Error = ParseError

impl<'doc> FromEure<'doc> for NodeId

type Error = ParseError

impl<'doc, K, T> FromEure<'doc> for Map<K, T>

where K: ParseObjectKey<'doc>, T: FromEure<'doc>, <T as FromEure<'doc>>::Error: From<ParseError>,

type Error = <T as FromEure<'doc>>::Error

impl<M> FromEure<'_> for MustBeText<M>

where M: MustBeTextMarker,

type Error = ParseError