104 lines
2.5 KiB
Rust
104 lines
2.5 KiB
Rust
use crate::mode::*;
|
|
|
|
use super::*;
|
|
|
|
/// [`Mode`] for [`InliningFactory`].
|
|
pub struct InliningMode;
|
|
|
|
impl Mode for InliningMode {
|
|
/// Keeps the parser.
|
|
type ParseSuccess<A, I> = (A, I);
|
|
|
|
/// Always fails.
|
|
type ExtensionResult<A, E> = E;
|
|
|
|
/// Discards the value.
|
|
type ExtensionSource<A> = ();
|
|
|
|
fn bind<A0, A1, E, I>(
|
|
s: Self::ParseSuccess<A0, I>,
|
|
f: impl FnOnce(A0) -> Result<A1, E>,
|
|
) -> ModeResult<Self, A1, E, I> {
|
|
let (a0, i) = s;
|
|
let a1 = f(a0)?;
|
|
Ok((a1, i))
|
|
}
|
|
|
|
fn map<A0, A1, I>(
|
|
s: Self::ParseSuccess<A0, I>,
|
|
f: impl FnOnce(A0) -> A1,
|
|
) -> Self::ParseSuccess<A1, I> {
|
|
(f(s.0), s.1)
|
|
}
|
|
|
|
fn seal<A, I>(s: Self::ParseSuccess<A, I>) -> A {
|
|
s.0
|
|
}
|
|
|
|
fn xmap_err<A, E0, E1>(
|
|
result: Self::ExtensionResult<A, E0>,
|
|
f: impl FnOnce(E0) -> E1,
|
|
) -> Self::ExtensionResult<A, E1> {
|
|
f(result)
|
|
}
|
|
|
|
fn xbind<A0, A1, E>(
|
|
result: Self::ExtensionResult<A0, E>,
|
|
_f: impl FnOnce(A0) -> Result<A1, E>,
|
|
) -> Self::ExtensionResult<A1, E> {
|
|
result
|
|
}
|
|
|
|
fn xseal<A, E>(result: Self::ExtensionResult<A, E>) -> Result<A, E> {
|
|
Err(result)
|
|
}
|
|
|
|
fn smap<A0, A1>(
|
|
source: Self::ExtensionSource<A0>,
|
|
_f: impl FnOnce(A0) -> A1,
|
|
) -> Self::ExtensionSource<A1> {
|
|
source
|
|
}
|
|
|
|
fn prepare<A>(_a: A) -> Self::ExtensionSource<A> {}
|
|
|
|
fn xsbind<AB, A, B, E>(
|
|
_ab: Self::ExtensionSource<AB>,
|
|
_t2ab: impl FnOnce(AB) -> (A, B),
|
|
ce: impl FnOnce(Self::ExtensionSource<B>) -> Self::ExtensionResult<B, E>,
|
|
_ab2t: impl FnOnce(A, B) -> Result<AB, E>,
|
|
) -> Self::ExtensionResult<AB, E> {
|
|
ce(())
|
|
}
|
|
}
|
|
|
|
impl<'a, Ctx: Context<'a>, F: CInliningFactory<'a, Ctx>> FactoryModeProxy<'a, Ctx>
|
|
for WithMode<F, InliningMode>
|
|
{
|
|
type F = F;
|
|
|
|
fn pmdeserialize<I: InCtx<'a, Ctx>>(f: &Self::F, inctx: I) -> ModeResultM<'a, Ctx, F, I> {
|
|
f.cideserialize(inctx)
|
|
}
|
|
|
|
fn pmextend(
|
|
f: &F,
|
|
_mentionable: ExtensionSourceM<'a, Ctx, F>,
|
|
tail: &[u8],
|
|
) -> ExtensionResultM<'a, Ctx, F> {
|
|
f.cextension_error(tail)
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|