Skip to main content

IntoEure

Trait IntoEure 

Source
pub trait IntoEure<T = Self>: Sized {
    type Error: From<WriteError>;

    // Required method
    fn write(value: T, c: &mut DocumentConstructor) -> Result<(), Self::Error>;

    // Provided method
    fn write_flatten(
        value: T,
        rec: &mut RecordWriter<'_>,
    ) -> Result<(), Self::Error> { ... }
}
Expand description

Trait for writing Rust types to Eure documents.

Types implementing this trait can be serialized into EureDocument via DocumentConstructor.

The generic parameter T defaults to Self, allowing remote type support via marker types:

  • IntoEure (same as IntoEure<Self>) - standard implementation
  • IntoEure<RemoteType> - marker type implements writing for a remote type

§Examples

Standard implementation:

impl IntoEure for User {
    type Error = WriteError;

    fn write(value: User, c: &mut DocumentConstructor) -> Result<(), Self::Error> {
        c.record(|rec| {
            rec.field("name", value.name)?;
            rec.field_optional("age", value.age)?;
            Ok::<(), WriteError>(())
        })
    }
}

Remote type support via marker:

impl IntoEure<std::time::Duration> for DurationDef {
    type Error = WriteError;

    fn write(value: std::time::Duration, c: &mut DocumentConstructor) -> Result<(), Self::Error> {
        c.record(|rec| {
            rec.field("secs", value.as_secs())?;
            rec.field("nanos", value.subsec_nanos())?;
            Ok::<(), WriteError>(())
        })
    }
}

Required Associated Types§

Source

type Error: From<WriteError>

The error type returned when writing.

This must be able to represent WriteError so document-constructor failures can be propagated through custom user errors.

Required Methods§

Source

fn write(value: T, c: &mut DocumentConstructor) -> Result<(), Self::Error>

Write a value to the current node in the document constructor.

Provided Methods§

Source

fn write_flatten( value: T, rec: &mut RecordWriter<'_>, ) -> Result<(), Self::Error>

Write a value as flattened record fields.

The default implementation returns a runtime error. Types that are record-like (e.g. named structs, map-like containers) should override this to emit fields into rec.

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§

Source§

impl IntoEure for bool

Source§

impl IntoEure for f32

Source§

impl IntoEure for f64

Source§

impl IntoEure for i8

Source§

impl IntoEure for i16

Source§

impl IntoEure for i32

Source§

impl IntoEure for i64

Source§

impl IntoEure for isize

Source§

impl IntoEure for u8

Source§

impl IntoEure for u16

Source§

impl IntoEure for u32

Source§

impl IntoEure for u64

Source§

impl IntoEure for usize

Source§

impl IntoEure for String

Source§

impl IntoEure for BigInt

Source§

impl IntoEure for Regex

Source§

type Error = WriteError

Source§

fn write(value: Self, c: &mut DocumentConstructor) -> Result<(), Self::Error>

Source§

impl<'a> IntoEure for &'a str

Source§

type Error = WriteError

Source§

fn write(value: &'a str, c: &mut DocumentConstructor) -> Result<(), Self::Error>

Source§

impl<'a, T> IntoEure for Cow<'a, T>
where T: ToOwned + ?Sized, T::Owned: IntoEure,

Source§

type Error = <<T as ToOwned>::Owned as IntoEure>::Error

Source§

fn write( value: Cow<'a, T>, c: &mut DocumentConstructor, ) -> Result<(), Self::Error>

Source§

impl<M, K, V> IntoEure<IndexMap<K, V>> for IndexMap<K, M>
where M: IntoEure<V>, K: Into<ObjectKey> + Eq + Hash,

Source§

type Error = <M as IntoEure<V>>::Error

Source§

fn write( value: IndexMap<K, V>, c: &mut DocumentConstructor, ) -> Result<(), Self::Error>

Source§

fn write_flatten( value: IndexMap<K, V>, rec: &mut RecordWriter<'_>, ) -> Result<(), Self::Error>

Source§

impl<M, T> IntoEure<Option<T>> for Option<M>
where M: IntoEure<T>,

Source§

type Error = <M as IntoEure<T>>::Error

Source§

fn write( value: Option<T>, c: &mut DocumentConstructor, ) -> Result<(), Self::Error>

Source§

impl<M, T> IntoEure<Vec<T>> for Vec<M>
where M: IntoEure<T>,

Source§

type Error = <M as IntoEure<T>>::Error

Source§

fn write(value: Vec<T>, c: &mut DocumentConstructor) -> Result<(), Self::Error>

Source§

impl<M, T, const N: usize> IntoEure<[T; N]> for [M; N]
where M: IntoEure<T>,

Source§

type Error = <M as IntoEure<T>>::Error

Source§

fn write(value: [T; N], c: &mut DocumentConstructor) -> Result<(), Self::Error>

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, MI, I, MJ, J, MK, K, ML, L, MM, M, MN, N, MO, O, MP, P, __E> IntoEure<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for (MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM, MN, MO, MP)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, MI: IntoEure<I, Error = __E>, MJ: IntoEure<J, Error = __E>, MK: IntoEure<K, Error = __E>, ML: IntoEure<L, Error = __E>, MM: IntoEure<M, Error = __E>, MN: IntoEure<N, Error = __E>, MO: IntoEure<O, Error = __E>, MP: IntoEure<P, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, MI, I, MJ, J, MK, K, ML, L, MM, M, MN, N, MO, O, __E> IntoEure<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> for (MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM, MN, MO)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, MI: IntoEure<I, Error = __E>, MJ: IntoEure<J, Error = __E>, MK: IntoEure<K, Error = __E>, ML: IntoEure<L, Error = __E>, MM: IntoEure<M, Error = __E>, MN: IntoEure<N, Error = __E>, MO: IntoEure<O, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, MI, I, MJ, J, MK, K, ML, L, MM, M, MN, N, __E> IntoEure<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> for (MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM, MN)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, MI: IntoEure<I, Error = __E>, MJ: IntoEure<J, Error = __E>, MK: IntoEure<K, Error = __E>, ML: IntoEure<L, Error = __E>, MM: IntoEure<M, Error = __E>, MN: IntoEure<N, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, MI, I, MJ, J, MK, K, ML, L, MM, M, __E> IntoEure<(A, B, C, D, E, F, G, H, I, J, K, L, M)> for (MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, MI: IntoEure<I, Error = __E>, MJ: IntoEure<J, Error = __E>, MK: IntoEure<K, Error = __E>, ML: IntoEure<L, Error = __E>, MM: IntoEure<M, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, MI, I, MJ, J, MK, K, ML, L, __E> IntoEure<(A, B, C, D, E, F, G, H, I, J, K, L)> for (MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, MI: IntoEure<I, Error = __E>, MJ: IntoEure<J, Error = __E>, MK: IntoEure<K, Error = __E>, ML: IntoEure<L, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, MI, I, MJ, J, MK, K, __E> IntoEure<(A, B, C, D, E, F, G, H, I, J, K)> for (MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, MI: IntoEure<I, Error = __E>, MJ: IntoEure<J, Error = __E>, MK: IntoEure<K, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, MI, I, MJ, J, __E> IntoEure<(A, B, C, D, E, F, G, H, I, J)> for (MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, MI: IntoEure<I, Error = __E>, MJ: IntoEure<J, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, MI, I, __E> IntoEure<(A, B, C, D, E, F, G, H, I)> for (MA, MB, MC, MD, ME, MF, MG, MH, MI)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, MI: IntoEure<I, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, MH, H, __E> IntoEure<(A, B, C, D, E, F, G, H)> for (MA, MB, MC, MD, ME, MF, MG, MH)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, MH: IntoEure<H, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, MG, G, __E> IntoEure<(A, B, C, D, E, F, G)> for (MA, MB, MC, MD, ME, MF, MG)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, MG: IntoEure<G, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, MF, F, __E> IntoEure<(A, B, C, D, E, F)> for (MA, MB, MC, MD, ME, MF)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, MF: IntoEure<F, Error = __E>, __E: From<WriteError>,

Source§

impl<MA, A, MB, B, MC, C, MD, D, ME, E, __E> IntoEure<(A, B, C, D, E)> for (MA, MB, MC, MD, ME)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, ME: IntoEure<E, Error = __E>, __E: From<WriteError>,

Source§

type Error = __E

Source§

fn write( value: (A, B, C, D, E), c: &mut DocumentConstructor, ) -> Result<(), Self::Error>

Source§

impl<MA, A, MB, B, MC, C, MD, D, __E> IntoEure<(A, B, C, D)> for (MA, MB, MC, MD)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, MD: IntoEure<D, Error = __E>, __E: From<WriteError>,

Source§

type Error = __E

Source§

fn write( value: (A, B, C, D), c: &mut DocumentConstructor, ) -> Result<(), Self::Error>

Source§

impl<MA, A, MB, B, MC, C, __E> IntoEure<(A, B, C)> for (MA, MB, MC)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, MC: IntoEure<C, Error = __E>, __E: From<WriteError>,

Source§

type Error = __E

Source§

fn write( value: (A, B, C), c: &mut DocumentConstructor, ) -> Result<(), Self::Error>

Source§

impl<MA, A, MB, B, __E> IntoEure<(A, B)> for (MA, MB)
where MA: IntoEure<A, Error = __E>, MB: IntoEure<B, Error = __E>, __E: From<WriteError>,

Source§

type Error = __E

Source§

fn write(value: (A, B), c: &mut DocumentConstructor) -> Result<(), Self::Error>

Source§

impl<MA, A, __E> IntoEure<(A,)> for (MA,)
where MA: IntoEure<A, Error = __E>, __E: From<WriteError>,

Source§

type Error = __E

Source§

fn write(value: (A,), c: &mut DocumentConstructor) -> Result<(), Self::Error>

Implementors§