1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

pub use super::*;

/// Inlining version of [`AParseResult`]. Preserves the parser.
pub type AIParseResult<A, I> = Result<(A, I), AParseError<A>>;

/// For auto-deriving [`InliningAtomic`] from concrete implementations.
pub trait CInliningAtomic: AtomicBase + ImplMode<Mode = InliningMode> {
    /// Concrete implementation of [`InliningAtomic::a_extension_error`].
    fn ca_extension_error(tail: &[u8]) -> Self::AParseError;

    /// Concrete implementation of [`InliningAtomic::a_ideserialize`].
    fn ca_ideserialize<I: Stream>(stream: I) -> AIParseResult<Self, I>;
}

/// [`Atomic`] analogue of [`InliningFactory`]/[`InliningObject`].
///
/// [`InliningFactory`]: crate::rcore::InliningFactory
/// [`InliningObject`]: crate::rstd::inlining::InliningObject
pub trait InliningAtomic: AtomicBase + ParseMode<Mode = InliningMode> {
    /// Always fail on extension,
    /// as parsing of an inlining atomic should be determined without reaching EOF.
    fn a_extension_error(tail: &[u8]) -> Self::AParseError;

    /// Inlining version of [`Atomic::a_deserialize`]. Preserves the parser.
    fn a_ideserialize<I: Stream>(strean: I) -> AIParseResult<Self, I>;
}

impl<A: AtomicModeParse + ParseMode<Mode = InliningMode>> InliningAtomic for A {
    fn a_extension_error(tail: &[u8]) -> Self::AParseError {
        A::ma_extend((), tail)
    }

    fn a_ideserialize<I: Stream>(stream: I) -> AIParseResult<Self, I> {
        A::ma_deserialize(stream)
    }
}

impl<A: CInliningAtomic> AtomicModeProxy for WithMode<A, InliningMode> {
    type A = A;

    fn pma_deserialize<I: Stream>(stream: I) -> AModeResultM<Self::A, I> {
        A::ca_ideserialize(stream)
    }

    fn pma_extend(_atomic: AExtensionSourceM<Self::A>, tail: &[u8]) -> AExtensionResultM<Self::A> {
        A::ca_extension_error(tail)
    }
}