102 lines
3.1 KiB
Rust
102 lines
3.1 KiB
Rust
use crate::core::*;
|
|
use crate::std::*;
|
|
|
|
struct CastResolver<'a, Ctx: 'a + Context> {
|
|
points: Vec<Point<'a, Ctx, TypelessMentionable<'a, Ctx>>>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum CastError<'a> {
|
|
Typeless(TypelessError<'a>),
|
|
AddressIndexOutOfBounds {
|
|
index: usize,
|
|
length: usize,
|
|
},
|
|
AddressPointMismatch {
|
|
expected: Hash,
|
|
received: Hash,
|
|
index: usize,
|
|
},
|
|
}
|
|
|
|
impl<'a> Display for CastError<'a> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
CastError::Typeless(typeless_error) => {
|
|
f.write_fmt(format_args!("typeless cast error: {}", typeless_error))
|
|
}
|
|
CastError::AddressIndexOutOfBounds { index, length } => f.write_fmt(format_args!(
|
|
"cast index out of bound: {}>={}",
|
|
index, length
|
|
)),
|
|
CastError::AddressPointMismatch {
|
|
expected,
|
|
received,
|
|
index,
|
|
} => f.write_fmt(format_args!(
|
|
"address mismatch at index {}: {}>={}",
|
|
index,
|
|
hex::encode(expected),
|
|
hex::encode(received),
|
|
)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'a, Ctx: 'a + Context> Resolver<'a, Ctx> for CastResolver<'a, Ctx>
|
|
where
|
|
Ctx::LookupError<'a>: From<CastError<'a>>,
|
|
{
|
|
fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
|
|
let point = match self.points.get(address.index) {
|
|
Some(point) => point,
|
|
None => {
|
|
return Ctx::T::pure(Err(CastError::AddressIndexOutOfBounds {
|
|
index: address.index,
|
|
length: self.points.len(),
|
|
}
|
|
.into()));
|
|
}
|
|
};
|
|
if point.point != address.point {
|
|
return Ctx::T::pure(Err(CastError::AddressPointMismatch {
|
|
expected: point.point,
|
|
received: address.point,
|
|
index: address.index,
|
|
}
|
|
.into()));
|
|
}
|
|
Ctx::T::fmap(
|
|
|resolved| match resolved {
|
|
Ok(mentionable) => {
|
|
let resolver: Rc<dyn Resolver<'a, Ctx>> = Rc::new(CastResolver {
|
|
points: mentionable.points(),
|
|
});
|
|
Ok((mentionable.bytes(), resolver))
|
|
}
|
|
Err(error) => Err(match error {
|
|
ResolutionError::Lookup(lookup_error) => lookup_error,
|
|
ResolutionError::Parse(parse_error) => CastError::Typeless(parse_error).into(),
|
|
}),
|
|
},
|
|
point.resolve(),
|
|
)
|
|
}
|
|
}
|
|
|
|
pub type CastResult<'a, Ctx, A> =
|
|
Result<A, <<A as Mentionable<'a, Ctx>>::Fctr as Factory<'a, Ctx>>::ParseError>;
|
|
impl<'a, Ctx: Context> TypelessMentionable<'a, Ctx>
|
|
where
|
|
Ctx::LookupError<'a>: From<CastError<'a>>,
|
|
{
|
|
pub fn cast<A: Mentionable<'a, Ctx>>(&self, factory: A::Fctr) -> CastResult<'a, Ctx, A> {
|
|
factory.parse_slice(
|
|
&self.bytes(),
|
|
Rc::new(CastResolver {
|
|
points: self.points(),
|
|
}),
|
|
)
|
|
}
|
|
}
|