rcore::dectx

src/rcore.rs

@@ -4,6 +4,7 @@
 
 mod addresses;
 mod context;
+mod dectx;
 mod diagnostic;
 mod hashing;
 mod inctx;
@@ -23,6 +24,8 @@ use crate::func::*;
 
 pub use self::addresses::{Addresses, InliningAddresses};
 pub use self::context::Context;
+pub use self::dectx::DeCtx;
+use self::dectx::DeCtxT;
 pub use self::diagnostic::Diagnostic;
 pub use self::hashing::{Hash, HASH_SIZE, HASH_ZEROS};
 pub use self::inctx::InCtx;
@@ -66,58 +69,6 @@ pub type ParseResult<'a, Ctx, F> = Result<Mtbl<'a, Ctx, F>, <F as Factory<'a, Ct
 
 pub type ParseResultA<'a, Ctx, A> = Result<A, ParseErrorA<'a, Ctx, A>>;
 
-pub struct DeCtxT<'a: 'c, 'c, Ctx: Context<'a>> {
-    deserializer: &'c mut dyn Deserializer,
-    resolver: &'c Rc<dyn Resolver<'a, Ctx>>,
-    addresses: &'c mut Addresses,
-}
-
-pub trait DeCtx<'a, Ctx: Context<'a>> {
-    fn deserializer(&mut self) -> &mut dyn Deserializer;
-
-    fn tell(&self) -> usize;
-
-    fn next_address(&mut self) -> Result<Address, &[u8]>;
-
-    fn resolver(&self) -> Rc<dyn Resolver<'a, Ctx>>;
-
-    fn adr(
-        &mut self,
-    ) -> (
-        &mut Addresses,
-        &mut dyn Deserializer,
-        &Rc<dyn Resolver<'a, Ctx>>,
-    );
-}
-
-impl<'a: 'c, 'c, Ctx: Context<'a>> DeCtx<'a, Ctx> for DeCtxT<'a, 'c, Ctx> {
-    fn deserializer(&mut self) -> &mut dyn Deserializer {
-        self.deserializer
-    }
-
-    fn tell(&self) -> usize {
-        self.deserializer.tell()
-    }
-
-    fn next_address(&mut self) -> Result<Address, &[u8]> {
-        self.addresses.next(self.deserializer)
-    }
-
-    fn resolver(&self) -> Rc<dyn Resolver<'a, Ctx>> {
-        self.resolver.clone()
-    }
-
-    fn adr(
-        &mut self,
-    ) -> (
-        &mut Addresses,
-        &mut dyn Deserializer,
-        &Rc<dyn Resolver<'a, Ctx>>,
-    ) {
-        (&mut self.addresses, self.deserializer, self.resolver)
-    }
-}
-
 /// Trait representing deserialisation rules for [Mentionable]s.
 /// Crucial for [`crate::rstd::typeless`].
 pub trait Factory<'a, Ctx: Context<'a>>: 'a + Send + Sync + Clone {

src/rcore/dectx.rs

@@ -0,0 +1,53 @@
+use super::*;
+
+pub struct DeCtxT<'a: 'c, 'c, Ctx: Context<'a>> {
+    pub deserializer: &'c mut dyn Deserializer,
+    pub resolver: &'c Rc<dyn Resolver<'a, Ctx>>,
+    pub addresses: &'c mut Addresses,
+}
+
+pub trait DeCtx<'a, Ctx: Context<'a>> {
+    fn deserializer(&mut self) -> &mut dyn Deserializer;
+
+    fn tell(&self) -> usize;
+
+    fn next_address(&mut self) -> Result<Address, &[u8]>;
+
+    fn resolver(&self) -> Rc<dyn Resolver<'a, Ctx>>;
+
+    fn adr(
+        &mut self,
+    ) -> (
+        &mut Addresses,
+        &mut dyn Deserializer,
+        &Rc<dyn Resolver<'a, Ctx>>,
+    );
+}
+
+impl<'a: 'c, 'c, Ctx: Context<'a>> DeCtx<'a, Ctx> for DeCtxT<'a, 'c, Ctx> {
+    fn deserializer(&mut self) -> &mut dyn Deserializer {
+        self.deserializer
+    }
+
+    fn tell(&self) -> usize {
+        self.deserializer.tell()
+    }
+
+    fn next_address(&mut self) -> Result<Address, &[u8]> {
+        self.addresses.next(self.deserializer)
+    }
+
+    fn resolver(&self) -> Rc<dyn Resolver<'a, Ctx>> {
+        self.resolver.clone()
+    }
+
+    fn adr(
+        &mut self,
+    ) -> (
+        &mut Addresses,
+        &mut dyn Deserializer,
+        &Rc<dyn Resolver<'a, Ctx>>,
+    ) {
+        (&mut self.addresses, self.deserializer, self.resolver)
+    }
+}