105 lines
3.9 KiB
Rust
105 lines
3.9 KiB
Rust
//! Core module for ADN functionality.
|
|
//! Brings [`Mentionable`]/[`Factory`]/[`Origin`] concepts from the original implementation in Python.
|
|
//! Allows for more generic behaviour via [`Context`], as opposed to original async-only.
|
|
|
|
mod addresses;
|
|
mod context;
|
|
mod dectx;
|
|
mod diagnostic;
|
|
mod hashing;
|
|
mod inctx;
|
|
mod inlining;
|
|
mod origin;
|
|
mod point;
|
|
mod points;
|
|
mod resolution;
|
|
mod resolver_origin;
|
|
mod serialization;
|
|
mod slice_deserializer;
|
|
|
|
use std::{error::Error, rc::Rc};
|
|
|
|
use crate::func::context::*;
|
|
use crate::func::*;
|
|
|
|
use self::addresses::{Addresses, InliningAddresses};
|
|
pub use self::context::Context;
|
|
use self::dectx::{DeCtx, DeCtxT};
|
|
pub use self::diagnostic::Diagnostic;
|
|
pub use self::hashing::{Hash, HASH_SIZE, HASH_ZEROS};
|
|
pub use self::inctx::InCtx;
|
|
pub use self::inlining::{Inlining, InliningExt, InliningResultExt};
|
|
pub use self::origin::{OFctr, Origin};
|
|
pub use self::point::Point;
|
|
pub use self::points::TakesPoints;
|
|
pub use self::resolution::{
|
|
Address, HashResolution, HashResolutionResult, LookupError, Resolution, ResolutionError,
|
|
ResolutionFailure, ResolutionResult, Resolver, ResolverMap,
|
|
};
|
|
pub use self::serialization::{Deserializer, DeserializerExt, Serializable, Serializer};
|
|
pub use self::slice_deserializer::SliceDeserializer;
|
|
|
|
/// Helper alias for [`WeakFunctor::F`] of [`FunctorContext::T`].
|
|
pub type Wrapped<'a, Ctx, A> = WrapC<'a, A, Ctx>;
|
|
|
|
/// Fundamental trait for ADN objects.
|
|
pub trait Mentionable<'a, Ctx: Context<'a>>: 'a + Serializable {
|
|
/// Type of the associated factory.
|
|
type Fctr: Factory<'a, Ctx, Mtbl = Self>;
|
|
|
|
/// Value of the associated factory.
|
|
fn factory(&self) -> Self::Fctr;
|
|
/// See implementation for the definition.
|
|
/// Hash of all the references' points concatenated, ordered, non-unique.
|
|
/// Used for walking over object trees to ensure two objects with different references don't collide.
|
|
fn topology(&self) -> Hash {
|
|
let mut vec = Vec::new();
|
|
self.points_typed(&mut vec);
|
|
Ctx::hash(&vec)
|
|
}
|
|
/// References ([Point]s) to other objects. Typed.
|
|
fn points_typed(&self, points: &mut impl TakesPoints<'a, Ctx>);
|
|
}
|
|
|
|
pub type Fctr<'a, Ctx, A> = <A as Mentionable<'a, Ctx>>::Fctr;
|
|
|
|
/// Shorthand for the type of vaalues returned by [`Factory::deserialize`].
|
|
pub type ParseResult<'a, Ctx, F> = Result<Mtbl<'a, Ctx, F>, <F as Factory<'a, Ctx>>::ParseError>;
|
|
|
|
/// [`ParseResult`] associated with a [`Mentionable`] (instead of a [`Factory`]).
|
|
pub type ParseResultA<'a, Ctx, A> = Result<A, ParseErrorA<'a, Ctx, A>>;
|
|
|
|
/// Trait representing deserialisation rules for [Mentionable]s.
|
|
/// Crucial for [`crate::rstd::typeless`].
|
|
pub trait Factory<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone {
|
|
/// Type of the associated objects.
|
|
type Mtbl: Mentionable<'a, Ctx, Fctr = Self>;
|
|
/// Type of an error that [`Factory::deserialize`] can fail with.
|
|
type ParseError: 'a + Error;
|
|
|
|
/// See [`Deserializer`], [`Resolver`].
|
|
fn deserialize(&self, inctx: impl InCtx<'a, Ctx>) -> ParseResult<'a, Ctx, Self>;
|
|
/// Called by finite stream parsers if there's any data left.
|
|
fn extend(&self, mentionable: Self::Mtbl, tail: &[u8]) -> ParseResult<'a, Ctx, Self>;
|
|
}
|
|
|
|
/// [`Mentionable`] associated with the [`Factory`]. Mostly useful for `type` definitions.
|
|
pub type Mtbl<'a, Ctx, F> = <F as Factory<'a, Ctx>>::Mtbl;
|
|
|
|
/// [`Factory::ParseError`]. Mostly useful for `type` definitions.
|
|
pub type ParseError<'a, Ctx, F> = <F as Factory<'a, Ctx>>::ParseError;
|
|
|
|
/// [`Factory::ParseError`] associated with the [`Mentionable`].
|
|
/// Mostly useful for `type` definitions.
|
|
pub type ParseErrorA<'a, Ctx, A> = ParseError<'a, Ctx, Fctr<'a, Ctx, A>>;
|
|
|
|
/// Extension trait for factories.
|
|
pub trait FactoryExt<'a, Ctx: Context<'a>>: Factory<'a, Ctx> {
|
|
/// Parse the object from a slice.
|
|
fn parse_slice(
|
|
&self,
|
|
slice: &[u8],
|
|
resolver: &Rc<dyn Resolver<'a, Ctx>>,
|
|
) -> ParseResult<'a, Ctx, Self>;
|
|
}
|