84 lines
2.1 KiB
Rust
84 lines
2.1 KiB
Rust
//! Module responsible for making [Point]s [Mentionable].
|
|
|
|
use std::{error::Error, fmt::Display, rc::Rc};
|
|
|
|
use crate::core::*;
|
|
|
|
impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>> Serializable for Point<'a, Ctx, A> {
|
|
fn serialize(&self, serializer: &mut dyn Serializer) {
|
|
serializer.write(&self.point)
|
|
}
|
|
}
|
|
|
|
impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>> Mentionable<'a, Ctx> for Point<'a, Ctx, A> {
|
|
type Fctr = PointFactory<A::Fctr>;
|
|
|
|
fn factory(&self) -> Self::Fctr {
|
|
PointFactory {
|
|
factory: self.origin.factory(),
|
|
}
|
|
}
|
|
|
|
fn topology(&self) -> Hash {
|
|
Ctx::hash(&self.point)
|
|
}
|
|
|
|
fn points(&self, points: &mut Vec<Point<'a, Ctx, TypelessMentionable<'a, Ctx>>>) {
|
|
points.push(self.typeless());
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct PointFactory<F> {
|
|
factory: F,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum PointParseError {
|
|
WrongLength(usize),
|
|
}
|
|
|
|
impl Display for PointParseError {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
PointParseError::WrongLength(length) => f.write_fmt(format_args!(
|
|
"expected {} bytes, received {}.",
|
|
HASH_SIZE, length
|
|
)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Error for PointParseError {}
|
|
|
|
impl From<&[u8]> for PointParseError {
|
|
fn from(value: &[u8]) -> Self {
|
|
PointParseError::WrongLength(value.len())
|
|
}
|
|
}
|
|
|
|
impl<'a, Ctx: 'a + Context, A: Mentionable<'a, Ctx>> AsRef<[u8]> for Point<'a, Ctx, A> {
|
|
fn as_ref(&self) -> &[u8] {
|
|
&self.point
|
|
}
|
|
}
|
|
|
|
impl<'a, Ctx: 'a + Context, F: Factory<'a, Ctx>> Factory<'a, Ctx> for PointFactory<F> {
|
|
type Mtbl = Point<'a, Ctx, F::Mtbl>;
|
|
|
|
type ParseError = PointParseError;
|
|
|
|
fn deserialize(
|
|
&self,
|
|
deserializer: &mut dyn Deserializer,
|
|
resolver: Rc<dyn Resolver<'a, Ctx>>,
|
|
addresses: &mut Addresses,
|
|
) -> ParseResult<'a, Ctx, Self> {
|
|
Ok(addresses.next_point(deserializer, resolver, self.factory.clone())?)
|
|
}
|
|
|
|
fn unexpected_tail(&self, tail: &[u8]) -> Self::ParseError {
|
|
PointParseError::WrongLength(HASH_SIZE + tail.len())
|
|
}
|
|
}
|