64 lines
1.7 KiB
Rust
64 lines
1.7 KiB
Rust
use super::*;
|
|
|
|
impl<'a, Ctx: Context<'a>, A: MentionableBase<'a, Ctx>> Point<'a, Ctx, A>
|
|
where
|
|
A::Fctr: FactoryBase<'a, Ctx>,
|
|
{
|
|
/// Make a [Point] from an [Address].
|
|
pub fn from_address(
|
|
address: Address,
|
|
factory: A::Fctr,
|
|
resolver: Arc<dyn Resolver<'a, Ctx>>,
|
|
) -> Self {
|
|
Point {
|
|
point: address.point,
|
|
origin: Arc::new(ResolverOrigin {
|
|
r_factory: factory,
|
|
r_address: address,
|
|
r_resolver: resolver,
|
|
}),
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ResolverOrigin<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> {
|
|
r_factory: F,
|
|
r_address: Address,
|
|
r_resolver: Arc<dyn Resolver<'a, Ctx>>,
|
|
}
|
|
|
|
fn _resolve_origin<'a, Ctx: Context<'a>, F: FactoryParse<'a, Ctx>>(
|
|
origin: Arc<ResolverOrigin<'a, Ctx, F>>,
|
|
) -> Resolution<'a, Ctx, F::Mtbl> {
|
|
origin
|
|
.r_resolver
|
|
.clone()
|
|
.resolve_map(origin.r_address, move |resolved| {
|
|
let (src, resolver) = resolved.map_err(ResolutionError::Lookup)?;
|
|
let mentionable = origin
|
|
.r_factory
|
|
.parse_slice(&src, &resolver)
|
|
.map_err(ResolutionError::Parse)?;
|
|
Ok(Arc::new(mentionable))
|
|
})
|
|
}
|
|
|
|
impl<'a, Ctx: Context<'a>, F: FactoryBase<'a, Ctx>> Origin<'a, Ctx> for ResolverOrigin<'a, Ctx, F> {
|
|
type Mtbl = F::Mtbl;
|
|
|
|
fn factory(&self) -> OFctr<'a, Ctx, Self> {
|
|
self.r_factory.clone()
|
|
}
|
|
|
|
fn resolve(self: Arc<Self>) -> Resolution<'a, Ctx, Self::Mtbl>
|
|
where
|
|
F: FactoryParse<'a, Ctx>,
|
|
{
|
|
_resolve_origin(self)
|
|
}
|
|
|
|
fn resolve_bytes(self: Arc<Self>) -> HashResolution<'a, Ctx> {
|
|
self.r_resolver.clone().resolve(self.r_address)
|
|
}
|
|
}
|