diff --git a/benchmark/benchmark.rs b/benchmark/benchmark.rs index 5c050e596..24768a4b5 100644 --- a/benchmark/benchmark.rs +++ b/benchmark/benchmark.rs @@ -19,9 +19,13 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. +#![allow(incomplete_features)] +#![feature(generic_associated_types)] + use std::{io}; use capnp::{message, serialize, serialize_packed}; +use capnp::private::arena::{BuilderArena, ReaderArena}; use capnp::traits::Owned; pub mod common; @@ -43,14 +47,20 @@ pub mod eval_capnp { pub mod eval; trait TestCase { - type Request: for<'a> Owned<'a>; - type Response: for<'a> Owned<'a>; + type Request: Owned; + type Response: Owned; type Expectation; - fn setup_request(&self, rnd: &mut crate::common::FastRand, b: ::Builder) -> Self::Expectation; - fn handle_request(&self, r: ::Reader, b: ::Builder) - -> ::capnp::Result<()>; - fn check_response(&self, r: ::Reader, e: Self::Expectation) -> ::capnp::Result<()>; + fn setup_request<'a, A>(&self, rnd: &mut crate::common::FastRand, b: ::Builder<'a, A>) + -> Self::Expectation where A: BuilderArena; + + fn handle_request<'a, 'b, A, B>(&self, + r: ::Reader<'a, A>, + b: ::Builder<'b, B>) + -> ::capnp::Result<()> where A: ReaderArena, B: BuilderArena; + + fn check_response<'a, A>(&self, r: ::Reader<'a, A>, e: Self::Expectation) + -> ::capnp::Result<()> where A: ReaderArena; } trait Serialize { diff --git a/benchmark/carsales.rs b/benchmark/carsales.rs index 83636954c..d5b4c20fe 100644 --- a/benchmark/carsales.rs +++ b/benchmark/carsales.rs @@ -19,6 +19,8 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. +use capnp::private::arena::{BuilderArena, ReaderArena}; + use crate::common::*; use crate::carsales_capnp::{parking_lot, total_value, Color, car}; @@ -27,8 +29,8 @@ trait CarValue { } macro_rules! car_value_impl( - ($typ:ident) => ( - impl <'a> CarValue for car::$typ<'a> { + ($typ:ident, $arena_bound:ident) => ( + impl <'a, A> CarValue for car::$typ<'a, A> where A: $arena_bound { fn car_value (mut self) -> ::capnp::Result { #![allow(unused_mut)] let mut result : u64 = 0; @@ -75,13 +77,13 @@ macro_rules! car_value_impl( ) ); -car_value_impl!(Reader); -car_value_impl!(Builder); +car_value_impl!(Reader, ReaderArena); +car_value_impl!(Builder, BuilderArena); const MAKES : [&'static str; 5] = ["Toyota", "GM", "Ford", "Honda", "Tesla"]; const MODELS : [&'static str; 6] = ["Camry", "Prius", "Volt", "Accord", "Leaf", "Model S"]; -pub fn random_car(rng: &mut FastRand, mut car: car::Builder) { +pub fn random_car(rng: &mut FastRand, mut car: car::Builder) where A: BuilderArena { car.set_make(MAKES[rng.next_less_than(MAKES.len() as u32) as usize]); car.set_model(MODELS[rng.next_less_than(MODELS.len() as u32) as usize]); @@ -133,7 +135,9 @@ impl crate::TestCase for CarSales { type Response = total_value::Owned; type Expectation = u64; - fn setup_request(&self, rng: &mut FastRand, request: parking_lot::Builder) -> u64 { + fn setup_request(&self, rng: &mut FastRand, request: parking_lot::Builder) -> u64 + where A: BuilderArena + { let mut result = 0; let mut cars = request.init_cars(rng.next_less_than(200)); for ii in 0.. cars.len() { @@ -145,8 +149,9 @@ impl crate::TestCase for CarSales { result } - fn handle_request(&self, request: parking_lot::Reader, mut response: total_value::Builder) - -> ::capnp::Result<()> + fn handle_request(&self, request: parking_lot::Reader, mut response: total_value::Builder) + -> ::capnp::Result<()> + where A: ReaderArena, B: BuilderArena { let mut result = 0; for car in request.get_cars()?.iter() { @@ -156,7 +161,9 @@ impl crate::TestCase for CarSales { Ok(()) } - fn check_response(&self, response: total_value::Reader, expected: u64) -> ::capnp::Result<()> { + fn check_response(&self, response: total_value::Reader, expected: u64) -> ::capnp::Result<()> + where A: ReaderArena + { if response.get_amount() == expected { Ok(()) } else { diff --git a/benchmark/catrank.rs b/benchmark/catrank.rs index e418765c2..3565fbf8f 100644 --- a/benchmark/catrank.rs +++ b/benchmark/catrank.rs @@ -19,15 +19,27 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. +use capnp::private::arena::{BuilderArena, ReaderArena}; + use crate::common::*; use crate::catrank_capnp::*; -#[derive(Clone, Copy)] -pub struct ScoredResult<'a> { +pub struct ScoredResult<'a, A> { score: f64, - result: search_result::Reader<'a> + result: search_result::Reader<'a, A> } +impl <'a, A> Clone for ScoredResult<'a, A> { + fn clone(&self) -> Self { + Self { + score: self.score, + result: self.result, + } + } +} + +impl <'a, A> Copy for ScoredResult<'a, A> {} + const URL_PREFIX: &'static str = "http://example.com"; pub struct CatRank; @@ -37,7 +49,9 @@ impl crate::TestCase for CatRank { type Response = search_result_list::Owned; type Expectation = i32; - fn setup_request(&self, rng: &mut FastRand, request: search_result_list::Builder) -> i32 { + fn setup_request(&self, rng: &mut FastRand, request: search_result_list::Builder) -> i32 + where A: BuilderArena + { let count = rng.next_less_than(1000); let mut good_count: i32 = 0; @@ -84,10 +98,11 @@ impl crate::TestCase for CatRank { good_count } - fn handle_request(&self, request: search_result_list::Reader, - response: search_result_list::Builder) -> ::capnp::Result<()> + fn handle_request(&self, request: search_result_list::Reader, + response: search_result_list::Builder) -> ::capnp::Result<()> + where A: ReaderArena, B: BuilderArena { - let mut scored_results: Vec = Vec::new(); + let mut scored_results: Vec> = Vec::new(); let results = request.get_results()?; for i in 0..results.len() { @@ -119,8 +134,9 @@ impl crate::TestCase for CatRank { Ok(()) } - fn check_response(&self, response: search_result_list::Reader, expected_good_count: i32) - -> ::capnp::Result<()> + fn check_response(&self, response: search_result_list::Reader, expected_good_count: i32) + -> ::capnp::Result<()> + where A: ReaderArena { let mut good_count : i32 = 0; let results = response.get_results()?; diff --git a/benchmark/eval.rs b/benchmark/eval.rs index 96e6c7b69..709860869 100644 --- a/benchmark/eval.rs +++ b/benchmark/eval.rs @@ -19,10 +19,12 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. +use capnp::private::arena::{BuilderArena, ReaderArena}; + use crate::common::*; use crate::eval_capnp::{expression, evaluation_result, Operation}; -fn make_expression(rng: &mut FastRand, mut exp: expression::Builder, depth : u32) -> i32 { +fn make_expression(rng: &mut FastRand, mut exp: expression::Builder, depth : u32) -> i32 { exp.set_op(::capnp::traits::FromU16::from_u16(rng.next_less_than( Operation::Modulus as u32 + 1) as u16).unwrap()); let left : i32 = @@ -52,7 +54,7 @@ fn make_expression(rng: &mut FastRand, mut exp: expression::Builder, depth : u32 } } -fn evaluate_expression(exp: expression::Reader) -> ::capnp::Result { +fn evaluate_expression(exp: expression::Reader) -> ::capnp::Result { let left = match exp.get_left().which()? { expression::left::Value(v) => v, expression::left::Expression(e) => evaluate_expression(e?)?, @@ -78,18 +80,21 @@ impl crate::TestCase for Eval { type Response = evaluation_result::Owned; type Expectation = i32; - fn setup_request(&self, rng: &mut FastRand, request: expression::Builder) -> i32 { + fn setup_request(&self, rng: &mut FastRand, request: expression::Builder) -> i32 where A: BuilderArena { make_expression(rng, request, 0) } - fn handle_request(&self, request: expression::Reader, mut response: evaluation_result::Builder) - -> ::capnp::Result<()> + fn handle_request(&self, request: expression::Reader, mut response: evaluation_result::Builder) + -> ::capnp::Result<()> + where A: ReaderArena, B: BuilderArena { response.set_value(evaluate_expression(request)?); Ok(()) } - fn check_response(&self, response: evaluation_result::Reader, expected : i32) -> ::capnp::Result<()> { + fn check_response(&self, response: evaluation_result::Reader, expected : i32) -> ::capnp::Result<()> + where A: ReaderArena + { if response.get_value() == expected { Ok(()) } else { diff --git a/capnp/src/any_pointer.rs b/capnp/src/any_pointer.rs index ae0786669..e25c6ab8f 100644 --- a/capnp/src/any_pointer.rs +++ b/capnp/src/any_pointer.rs @@ -25,6 +25,7 @@ use alloc::boxed::Box; use alloc::vec::Vec; use crate::capability::FromClientHook; +use crate::private::arena::{BuilderArena, ReaderArena}; use crate::private::capability::{ClientHook, PipelineHook, PipelineOp}; use crate::private::layout::{PointerReader, PointerBuilder}; use crate::traits::{FromPointerReader, FromPointerBuilder, SetPointerBuilder}; @@ -33,9 +34,9 @@ use crate::Result; #[derive(Copy, Clone)] pub struct Owned(()); -impl <'a> crate::traits::Owned<'a> for Owned { - type Reader = Reader<'a>; - type Builder = Builder<'a>; +impl crate::traits::Owned for Owned { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A>; } impl crate::traits::Pipelined for Owned { @@ -43,13 +44,13 @@ impl crate::traits::Pipelined for Owned { } #[derive(Copy, Clone)] -pub struct Reader<'a> { - reader: PointerReader<'a> +pub struct Reader<'a, A> { + reader: PointerReader<&'a A> } -impl <'a> Reader<'a> { +impl <'a, A> Reader<'a, A> where A: ReaderArena { #[inline] - pub fn new<'b>(reader: PointerReader<'b>) -> Reader<'b> { + pub fn new<'b>(reader: PointerReader<&'b A>) -> Reader<'b, A> { Reader { reader: reader } } @@ -64,8 +65,8 @@ impl <'a> Reader<'a> { } #[inline] - pub fn get_as>(&self) -> Result { - FromPointerReader::get_from_pointer(&self.reader, None) + pub fn get_as>(&self) -> Result { + FromPointerReader::get_from_pointer(self.reader, None) } pub fn get_as_capability(&self) -> Result { @@ -90,40 +91,42 @@ impl <'a> Reader<'a> { } } -impl <'a> FromPointerReader<'a> for Reader<'a> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A> FromPointerReader<'a, A> for Reader<'a, A> where A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { if default.is_some() { panic!("Unsupported: any_pointer with a default value."); } - Ok(Reader { reader: *reader }) + Ok(Reader { reader: reader }) } } -impl <'a> crate::traits::SetPointerBuilder> for Reader<'a> { - fn set_pointer_builder<'b>(mut pointer: crate::private::layout::PointerBuilder<'b>, - value: Reader<'a>, - canonicalize: bool) -> Result<()> { +impl <'a, A> crate::traits::SetPointerBuilder for Reader<'a, A> where A: ReaderArena { + fn set_pointer_builder<'b, B>(mut pointer: crate::private::layout::PointerBuilder<&'b mut B>, + value: Reader<'a, A>, + canonicalize: bool) -> Result<()> + where B: BuilderArena + { pointer.copy_from(value.reader, canonicalize) } } -impl <'a> crate::traits::Imbue<'a> for Reader<'a> { +impl <'a, A> crate::traits::Imbue<'a> for Reader<'a, A> where A: ReaderArena { fn imbue(&mut self, cap_table: &'a crate::private::layout::CapTable) { self.reader.imbue(crate::private::layout::CapTableReader::Plain(cap_table)); } } -pub struct Builder<'a> { - builder: PointerBuilder<'a> +pub struct Builder<'a, A> { + builder: PointerBuilder<&'a mut A> } -impl <'a> Builder<'a> { +impl <'a, A> Builder<'a, A> where A: BuilderArena { #[inline] - pub fn new(builder: PointerBuilder<'a>) -> Builder<'a> { + pub fn new(builder: PointerBuilder<&'a mut A>) -> Builder<'a, A> { Builder { builder: builder } } - pub fn reborrow<'b>(&'b mut self) -> Builder<'b> { + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A> { Builder { builder: self.builder.borrow() } } @@ -133,23 +136,23 @@ impl <'a> Builder<'a> { /// Gets the total size of the target and all of its children. Does not count far pointer overhead. pub fn target_size(&self) -> Result { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } - pub fn get_as>(self) -> Result { + pub fn get_as>(self) -> Result { FromPointerBuilder::get_from_pointer(self.builder, None) } - pub fn init_as>(self) -> T { + pub fn init_as>(self) -> T { FromPointerBuilder::init_pointer(self.builder, 0) } - pub fn initn_as>(self, size: u32) -> T { + pub fn initn_as>(self, size: u32) -> T { FromPointerBuilder::init_pointer(self.builder, size) } - pub fn set_as>(self, value: From) -> Result<()> { - SetPointerBuilder::::set_pointer_builder(self.builder, value, false) + pub fn set_as(self, value: From) -> Result<()> { + SetPointerBuilder::set_pointer_builder(self.builder, value, false) } // XXX value should be a user client. @@ -162,19 +165,19 @@ impl <'a> Builder<'a> { self.builder.clear() } - pub fn into_reader(self) -> Reader<'a> { + pub fn into_reader(self) -> Reader<'a, A> { Reader { reader: self.builder.into_reader() } } } -impl <'a> FromPointerBuilder<'a> for Builder<'a> { - fn init_pointer(mut builder: PointerBuilder<'a>, _len: u32) -> Builder<'a> { +impl <'a, A> FromPointerBuilder<'a, A> for Builder<'a, A> where A: BuilderArena { + fn init_pointer(mut builder: PointerBuilder<&'a mut A>, _len: u32) -> Builder<'a, A> { if !builder.is_null() { builder.clear(); } Builder { builder: builder } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { if default.is_some() { panic!("AnyPointer defaults are unsupported") } @@ -182,7 +185,7 @@ impl <'a> FromPointerBuilder<'a> for Builder<'a> { } } -impl <'a> crate::traits::ImbueMut<'a> for Builder<'a> { +impl <'a, A> crate::traits::ImbueMut<'a> for Builder<'a, A> where A: BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut crate::private::layout::CapTable) { self.builder.imbue(crate::private::layout::CapTableBuilder::Plain(cap_table)); } @@ -228,15 +231,15 @@ impl crate::capability::FromTypelessPipeline for Pipeline { fn init_clears_value() { let mut message = crate::message::Builder::new_default(); { - let root: crate::any_pointer::Builder = message.init_root(); - let mut list: crate::primitive_list::Builder = root.initn_as(10); + let root: crate::any_pointer::Builder<_> = message.init_root(); + let mut list: crate::primitive_list::Builder<_, u16> = root.initn_as(10); for idx in 0..10 { list.set(idx, idx as u16); } } { - let root: crate::any_pointer::Builder = message.init_root(); + let root: crate::any_pointer::Builder<_> = message.init_root(); assert!(root.is_null()); } diff --git a/capnp/src/any_pointer_list.rs b/capnp/src/any_pointer_list.rs index 2d0ec8e2c..41c9ed54d 100644 --- a/capnp/src/any_pointer_list.rs +++ b/capnp/src/any_pointer_list.rs @@ -24,109 +24,113 @@ //! as pointer lists. use crate::traits::{FromPointerReader, FromPointerBuilder, ListIter, IndexMove}; +use crate::private::arena::{ReaderArena, BuilderArena}; use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, Pointer}; use crate::Result; #[derive(Clone, Copy)] pub struct Owned; -impl <'a> crate::traits::Owned<'a> for Owned { - type Reader = Reader<'a>; - type Builder = Builder<'a>; +impl crate::traits::Owned for Owned { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A>; } #[derive(Clone, Copy)] -pub struct Reader<'a> { - pub reader: ListReader<'a> +pub struct Reader<'a, A> { + pub reader: ListReader<&'a A> } -impl <'a> Reader<'a> { - pub fn new<'b>(reader: ListReader<'b>) -> Reader<'b> { +impl <'a, A> Reader<'a, A> where A: ReaderArena { + pub(crate) fn new<'b>(reader: ListReader<&'b A>) -> Reader<'b, A> { Reader { reader: reader } } pub fn len(&self) -> u32 { self.reader.len() } - pub fn iter(self) -> ListIter, Result>>{ + pub fn iter(self) -> ListIter, Result>>{ let l = self.len(); ListIter::new(self, l) } - pub fn get(self, index : u32) -> crate::any_pointer::Reader<'a> { + pub fn get(self, index : u32) -> crate::any_pointer::Reader<'a, A> { assert!(index < self.len()); crate::any_pointer::Reader::new(self.reader.get_pointer_element(index)) } } -impl <'a> IndexMove>> for Reader<'a>{ - fn index_move(&self, index: u32) -> Result> { +impl <'a, A> IndexMove>> for Reader<'a, A> +where A: ReaderArena, + Self: Copy // TODO why is this Copy needed? +{ + fn index_move(&self, index: u32) -> Result> { Ok(self.get(index)) } } -impl <'a> FromPointerReader<'a> for Reader<'a> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A> FromPointerReader<'a, A> for Reader<'a, A> where A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Reader { reader: reader.get_list(Pointer, default)? }) } } -impl <'a> crate::traits::IntoInternalListReader<'a> for Reader<'a> { - fn into_internal_list_reader(self) -> ListReader<'a> { +impl <'a, A> crate::traits::IntoInternalListReader<'a, A> for Reader<'a, A> where A: ReaderArena { + fn into_internal_list_reader(self) -> ListReader<&'a A> { self.reader } } -pub struct Builder<'a> { - builder: ListBuilder<'a> +pub struct Builder<'a, A> { + builder: ListBuilder<&'a mut A> } -impl <'a> Builder<'a> { - pub fn new(builder: ListBuilder<'a>) -> Builder<'a> { - Builder { builder: builder } - } - +impl <'a, A> Builder<'a, A> where A: BuilderArena { pub fn len(&self) -> u32 { self.builder.len() } - pub fn into_reader(self) -> Reader<'a> { + pub fn into_reader(self) -> Reader<'a, A> { Reader { reader: self.builder.into_reader() } } - pub fn get(self, index : u32) -> crate::any_pointer::Builder<'a> { + pub fn get(self, index: u32) -> crate::any_pointer::Builder<'a, A> { assert!(index < self.len()); crate::any_pointer::Builder::new(self.builder.get_pointer_element(index)) } - pub fn reborrow<'b>(&'b mut self) -> Builder<'b> { - Builder {builder: self.builder.borrow()} + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A> { + Builder {builder: self.builder.reborrow()} } } -impl <'a> FromPointerBuilder<'a> for Builder<'a> { - fn init_pointer(builder: PointerBuilder<'a>, size : u32) -> Builder<'a> { +impl <'a, A> FromPointerBuilder<'a, A> for Builder<'a, A> where A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, size : u32) -> Builder<'a, A> { Builder { builder: builder.init_list(Pointer, size) } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Builder { builder: builder.get_list(Pointer, default)? }) } } -impl <'a> crate::traits::SetPointerBuilder> for Reader<'a> { - fn set_pointer_builder<'b>(pointer: PointerBuilder<'b>, - value: Reader<'a>, - canonicalize: bool) -> Result<()> { +impl <'a, A> crate::traits::SetPointerBuilder for Reader<'a, A> where A: ReaderArena { + fn set_pointer_builder<'b, B>(pointer: PointerBuilder<&'b mut B>, + value: Reader<'a, A>, + canonicalize: bool) -> Result<()> + where B: BuilderArena + { pointer.set_list(&value.reader, canonicalize)?; Ok(()) } } -impl <'a> core::iter::IntoIterator for Reader<'a> { - type Item = Result>; - type IntoIter = ListIter, Self::Item>; +impl <'a, A> core::iter::IntoIterator for Reader<'a, A> +where A: ReaderArena + Copy //TODO why is this Copy needed? +{ + type Item = Result>; + type IntoIter = ListIter, Self::Item>; fn into_iter(self) -> Self::IntoIter { self.iter() diff --git a/capnp/src/capability.rs b/capnp/src/capability.rs index 87b9991df..dbe55f2df 100644 --- a/capnp/src/capability.rs +++ b/capnp/src/capability.rs @@ -104,7 +104,7 @@ impl Try for Promise { /// A promise for a result from a method call. #[must_use] -pub struct RemotePromise where Results: Pipelined + for<'a> Owned<'a> + 'static { +pub struct RemotePromise where Results: Pipelined + Owned + 'static { pub promise: Promise, crate::Error>, pub pipeline: Results::Pipeline, } @@ -115,6 +115,7 @@ pub struct Response { pub hook: Box, } +/* impl Response where Results: Pipelined + for<'a> Owned<'a> { @@ -125,6 +126,7 @@ impl Response self.hook.get()?.get_as() } } +*/ /// A method call that has not been sent yet. pub struct Request { @@ -132,6 +134,7 @@ pub struct Request { pub hook: Box } +/* impl Request where Params: for<'a> Owned<'a> { @@ -164,6 +167,7 @@ where Results: Pipelined + for<'a> Owned<'a> + 'static + Unpin, } } } +*/ /// The values of the parameters passed to a method call, as seen by the server. pub struct Params { @@ -175,11 +179,11 @@ impl Params { pub fn new(hook: Box) -> Params { Params { marker: PhantomData, hook: hook } } - pub fn get<'a>(&'a self) -> crate::Result<>::Reader> +/* pub fn get<'a>(&'a self) -> crate::Result<>::Reader> where T: Owned<'a> { Ok(self.hook.get()?.get_as()?) - } + }*/ } /// The return values of a method, written in-place by the method body. @@ -189,12 +193,12 @@ pub struct Results { } impl Results - where T: for<'a> Owned<'a> +// where T: for<'a> Owned<'a> { pub fn new(hook: Box) -> Results { Results { marker: PhantomData, hook: hook } } - +/* pub fn get<'a>(&'a mut self) -> >::Builder { self.hook.get().unwrap().get_as().unwrap() } @@ -202,7 +206,7 @@ impl Results pub fn set(&mut self, other: ::Reader) -> crate::Result<()> { self.hook.get().unwrap().set_as(other) - } + }*/ } pub trait FromTypelessPipeline { @@ -231,7 +235,7 @@ impl Client { let typeless = self.hook.new_call(interface_id, method_id, size_hint); Request { hook: typeless.hook, marker: PhantomData } } - +/* /// If the capability is actually only a promise, the returned promise resolves once the /// capability itself has resolved to its final destination (or propagates the exception if /// the capability promise is rejected). This is mainly useful for error-checking in the case @@ -240,6 +244,7 @@ impl Client { pub fn when_resolved(&self) -> Promise<(), Error> { self.hook.when_resolved() } +*/ } /// An untyped server. diff --git a/capnp/src/capability_list.rs b/capnp/src/capability_list.rs index e9845b389..21d124006 100644 --- a/capnp/src/capability_list.rs +++ b/capnp/src/capability_list.rs @@ -24,6 +24,7 @@ use alloc::boxed::Box; use core::marker::PhantomData; use crate::capability::{FromClientHook}; +use crate::private::arena::{ReaderArena, BuilderArena}; use crate::private::capability::ClientHook; use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, Pointer}; use crate::traits::{FromPointerReader, FromPointerBuilder, IndexMove, ListIter}; @@ -34,75 +35,66 @@ pub struct Owned where T: FromClientHook { marker: PhantomData, } -impl<'a, T> crate::traits::Owned<'a> for Owned where T: FromClientHook { - type Reader = Reader<'a, T>; - type Builder = Builder<'a, T>; +impl crate::traits::Owned for Owned where T: FromClientHook { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A, T>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A, T>; } -pub struct Reader<'a, T> where T: FromClientHook { +pub struct Reader<'a, A, T> where T: FromClientHook, A: ReaderArena { marker: PhantomData, - reader: ListReader<'a> + reader: ListReader<&'a A>, } -impl <'a, T> Clone for Reader<'a, T> where T: FromClientHook { - fn clone(&self) -> Reader<'a, T> { +impl <'a, A, T> Clone for Reader<'a, A, T> where T: FromClientHook, A: ReaderArena { + fn clone(&self) -> Reader<'a, A, T> { Reader { marker : self.marker, reader : self.reader } } } -impl <'a, T> Copy for Reader<'a, T> where T: FromClientHook {} - -impl <'a, T> Reader<'a, T> where T: FromClientHook { - pub fn new<'b>(reader : ListReader<'b>) -> Reader<'b, T> { - Reader::<'b, T> { reader : reader, marker : PhantomData } - } +impl <'a, A, T> Copy for Reader<'a, A, T> where T: FromClientHook, A: ReaderArena {} +impl <'a, A, T> Reader<'a, A, T> where T: FromClientHook, A: ReaderArena { pub fn len(&self) -> u32 { self.reader.len() } - pub fn iter(self) -> ListIter, Result> { + pub fn iter(self) -> ListIter, Result> { ListIter::new(self, self.len()) } } - -impl <'a, T> Reader<'a, T> where T: FromClientHook { - pub fn reborrow<'b>(&'b self) -> Reader<'b, T> { +impl <'a, A, T> Reader<'a, A, T> where T: FromClientHook, A: ReaderArena { + pub fn reborrow<'b>(&'b self) -> Reader<'b, A, T> { Reader { reader: self.reader, marker: PhantomData } } } -impl <'a, T> FromPointerReader<'a> for Reader<'a, T> where T: FromClientHook { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A, T> FromPointerReader<'a, A> for Reader<'a, A, T> where T: FromClientHook, A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Reader { reader: reader.get_list(Pointer, default)?, marker: PhantomData }) } } -impl <'a, T> Reader<'a, T> where T: FromClientHook { +impl <'a, A, T> Reader<'a, A, T> where T: FromClientHook, A: ReaderArena { pub fn get(self, index: u32) -> Result { assert!(index < self.len()); Ok(FromClientHook::new(self.reader.get_pointer_element(index).get_capability()?)) } } -impl <'a, T> IndexMove> for Reader<'a, T> where T: FromClientHook { +impl <'a, A, T> IndexMove> for Reader<'a, A, T> where T: FromClientHook, A: ReaderArena { fn index_move(&self, index: u32) -> Result { self.get(index) } } -pub struct Builder<'a, T> where T: FromClientHook { +pub struct Builder<'a, A, T> where T: FromClientHook, A: BuilderArena { marker: PhantomData, - builder: ListBuilder<'a> + builder: ListBuilder<&'a mut A>, } -impl <'a, T> Builder<'a, T> where T: FromClientHook { - pub fn new(builder : ListBuilder<'a>) -> Builder<'a, T> { - Builder { builder: builder, marker: PhantomData } - } - +impl <'a, A, T> Builder<'a, A, T> where T: FromClientHook, A: BuilderArena { pub fn len(&self) -> u32 { self.builder.len() } - pub fn into_reader(self) -> Reader<'a, T> { + pub fn into_reader(self) -> Reader<'a, A, T> { Reader { marker: PhantomData, reader: self.builder.into_reader(), @@ -111,24 +103,24 @@ impl <'a, T> Builder<'a, T> where T: FromClientHook { pub fn set(&mut self, index: u32, value: Box) { assert!(index < self.len()); - self.builder.borrow().get_pointer_element(index).set_capability(value); + self.builder.reborrow().get_pointer_element(index).set_capability(value); } } -impl <'a, T> Builder<'a, T> where T: FromClientHook { - pub fn reborrow<'b>(&'b mut self) -> Builder<'b, T> { - Builder { builder: self.builder, marker: PhantomData } +impl <'a, A, T> Builder<'a, A, T> where T: FromClientHook, A: BuilderArena { + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A, T> { + Builder { builder: self.builder.reborrow(), marker: PhantomData } } } -impl <'a, T> FromPointerBuilder<'a> for Builder<'a, T> where T: FromClientHook { - fn init_pointer(builder: PointerBuilder<'a>, size: u32) -> Builder<'a, T> { +impl <'a, A, T> FromPointerBuilder<'a, A> for Builder<'a, A, T> where T: FromClientHook, A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, size: u32) -> Builder<'a, A, T> { Builder { marker: PhantomData, builder: builder.init_list(Pointer, size), } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Builder { marker: PhantomData, builder: builder.get_list(Pointer, default)? @@ -136,28 +128,32 @@ impl <'a, T> FromPointerBuilder<'a> for Builder<'a, T> where T: FromClientHook { } } -impl <'a, T> Builder<'a, T> where T: FromClientHook { +impl <'a, A, T> Builder<'a, A, T> where T: FromClientHook, A: BuilderArena { pub fn get(self, index: u32) -> Result { assert!(index < self.len()); Ok(FromClientHook::new(self.builder.get_pointer_element(index).get_capability()?)) } } -impl <'a, T> crate::traits::SetPointerBuilder> for Reader<'a, T> - where T: FromClientHook +impl <'a, A, T> crate::traits::SetPointerBuilder for Reader<'a, A, T> +where T: FromClientHook, + A: ReaderArena { - fn set_pointer_builder<'b>(pointer: crate::private::layout::PointerBuilder<'b>, - value: Reader<'a, T>, - canonicalize: bool) -> Result<()> { + fn set_pointer_builder<'b, B>(pointer: crate::private::layout::PointerBuilder<&'b mut B>, + value: Reader<'a, A, T>, + canonicalize: bool) -> Result<()> + where B: BuilderArena + { pointer.set_list(&value.reader, canonicalize) } } -impl <'a, T> ::core::iter::IntoIterator for Reader<'a, T> - where T: FromClientHook +impl <'a, A, T> ::core::iter::IntoIterator for Reader<'a, A, T> +where T: FromClientHook, + A: ReaderArena { type Item = Result; - type IntoIter = ListIter, Self::Item>; + type IntoIter = ListIter, Self::Item>; fn into_iter(self) -> Self::IntoIter { self.iter() diff --git a/capnp/src/constant.rs b/capnp/src/constant.rs index 39a5f9af6..205b1c709 100644 --- a/capnp/src/constant.rs +++ b/capnp/src/constant.rs @@ -26,6 +26,7 @@ use core::marker::PhantomData; use crate::any_pointer; +use crate::private::arena::NullArena; use crate::private::layout::PointerReader; use crate::traits::Owned; use crate::{Result}; @@ -40,9 +41,9 @@ pub struct Reader { pub words: &'static [crate::Word], } -impl Reader where T: for<'a> Owned<'a> { +impl Reader where T: Owned { /// Retrieve the value. - pub fn get(&self) -> Result<>::Reader> { + pub fn get(&self) -> Result<::Reader<'static, NullArena>> { any_pointer::Reader::new(PointerReader::get_root_unchecked(self.words.as_ptr() as *const u8)).get_as() } } diff --git a/capnp/src/data.rs b/capnp/src/data.rs index 8bcd8beb0..c3879f990 100644 --- a/capnp/src/data.rs +++ b/capnp/src/data.rs @@ -21,58 +21,51 @@ //! Sequence of bytes. +use crate::private::arena::{BuilderArena, ReaderArena}; use crate::private::layout::{PointerBuilder, PointerReader}; use crate::Result; #[derive(Copy, Clone)] pub struct Owned(()); -impl<'a> crate::traits::Owned<'a> for Owned { - type Reader = Reader<'a>; - type Builder = Builder<'a>; +impl crate::traits::Owned for Owned { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a>; } pub type Reader<'a> = &'a [u8]; -#[deprecated(since = "0.13.4", note = "This function is unsafe and was never intended for external use")] -pub fn new_reader<'a>(p : *const u8, len : u32) -> Reader<'a> { - unsafe { ::core::slice::from_raw_parts(p, len as usize) } -} - pub(crate) unsafe fn reader_from_raw_parts<'a>(p: *const u8, len: u32) -> Reader<'a> { ::core::slice::from_raw_parts(p, len as usize) } -impl <'a> crate::traits::FromPointerReader<'a> for Reader<'a> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A> crate::traits::FromPointerReader<'a, A> for Reader<'a> where A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { reader.get_data(default) } } pub type Builder<'a> = &'a mut [u8]; -#[deprecated(since = "0.13.4", note = "This function is unsafe and was never intended for external use")] -pub fn new_builder<'a>(p : *mut u8, len : u32) -> Builder<'a> { - unsafe { ::core::slice::from_raw_parts_mut(p, len as usize) } -} - pub(crate) unsafe fn builder_from_raw_parts<'a>(p: *mut u8, len: u32) -> Builder<'a> { ::core::slice::from_raw_parts_mut(p, len as usize) } -impl <'a> crate::traits::FromPointerBuilder<'a> for Builder<'a> { - fn init_pointer(builder : PointerBuilder<'a>, size : u32) -> Builder<'a> { +impl <'a, A> crate::traits::FromPointerBuilder<'a, A> for Builder<'a> where A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, size : u32) -> Builder<'a> { builder.init_data(size) } - fn get_from_pointer(builder :PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { builder.get_data(default) } } -impl <'a> crate::traits::SetPointerBuilder> for Reader<'a> { - fn set_pointer_builder<'b>(pointer: PointerBuilder<'b>, - value: Reader<'a>, - _canonicalize: bool) -> Result<()> { +impl <'a> crate::traits::SetPointerBuilder for Reader<'a> { + fn set_pointer_builder<'b, B>(pointer: PointerBuilder<&'b mut B>, + value: Reader<'a>, + _canonicalize: bool) -> Result<()> + where B: BuilderArena + { pointer.set_data(value); Ok(()) } diff --git a/capnp/src/data_list.rs b/capnp/src/data_list.rs index 20456d2a9..32aceb027 100644 --- a/capnp/src/data_list.rs +++ b/capnp/src/data_list.rs @@ -22,101 +22,93 @@ //! List of sequences of bytes. use crate::traits::{FromPointerReader, FromPointerBuilder, IndexMove, ListIter}; +use crate::private::arena::{ReaderArena, BuilderArena}; use crate::private::layout::*; use crate::Result; #[derive(Copy, Clone)] pub struct Owned; -impl <'a> crate::traits::Owned<'a> for Owned { - type Reader = Reader<'a>; - type Builder = Builder<'a>; +impl crate::traits::Owned for Owned { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A>; } #[derive(Clone, Copy)] -pub struct Reader<'a> { - pub reader: ListReader<'a> +pub struct Reader<'a, A> { + pub reader: ListReader<&'a A> } -impl <'a> Reader<'a> { - pub fn new<'b>(reader: ListReader<'b>) -> Reader<'b> { - Reader { reader: reader } - } - +impl <'a, A> Reader<'a, A> where A: ReaderArena { pub fn len(&self) -> u32 { self.reader.len() } - pub fn iter(self) -> ListIter, Result>>{ + pub fn iter(self) -> ListIter, Result>>{ let l = self.len(); ListIter::new(self, l) } } -impl <'a> FromPointerReader<'a> for Reader<'a> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A> FromPointerReader<'a, A> for Reader<'a, A> where A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Reader { reader: reader.get_list(Pointer, default)? }) } } -impl <'a> IndexMove>> for Reader<'a>{ +impl <'a, A> IndexMove>> for Reader<'a, A> where A: ReaderArena { fn index_move(&self, index: u32) -> Result> { self.get(index) } } -impl <'a> Reader<'a> { - pub fn get(self, index : u32) -> Result> { - assert!(index < self.len()); +impl <'a, A> Reader<'a, A> where A: ReaderArena { + pub fn get(&self, index: u32) -> Result> { + assert!(index < self.len()); self.reader.get_pointer_element(index).get_data(None) } } -impl <'a> crate::traits::IntoInternalListReader<'a> for Reader<'a> { - fn into_internal_list_reader(self) -> ListReader<'a> { +impl <'a, A> crate::traits::IntoInternalListReader<'a, A> for Reader<'a, A> where A: ReaderArena { + fn into_internal_list_reader(self) -> ListReader<&'a A> { self.reader } } -pub struct Builder<'a> { - builder: ListBuilder<'a> +pub struct Builder<'a, A> { + builder: ListBuilder<&'a mut A> } -impl <'a> Builder<'a> { - pub fn new(builder: ListBuilder<'a>) -> Builder<'a> { - Builder { builder: builder } - } - +impl <'a, A> Builder<'a, A> where A: BuilderArena { pub fn len(&self) -> u32 { self.builder.len() } - pub fn into_reader(self) -> Reader<'a> { + pub fn into_reader(self) -> Reader<'a, A> { Reader { reader: self.builder.into_reader() } } pub fn set(&mut self, index: u32, value: crate::data::Reader) { assert!(index < self.len()); - self.builder.borrow().get_pointer_element(index).set_data(value); + self.builder.reborrow().get_pointer_element(index).set_data(value); } - pub fn reborrow<'b>(&'b mut self) -> Builder<'b> { - Builder {builder: self.builder.borrow()} + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A> { + Builder {builder: self.builder.reborrow()} } } - -impl <'a> FromPointerBuilder<'a> for Builder<'a> { - fn init_pointer(builder: PointerBuilder<'a>, size : u32) -> Builder<'a> { +impl <'a, A> FromPointerBuilder<'a, A> for Builder<'a, A> where A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, size : u32) -> Builder<'a, A> { Builder { builder: builder.init_list(Pointer, size) } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Builder { builder: builder.get_list(Pointer, default)? }) } } -impl <'a> Builder<'a> { +impl <'a, A> Builder<'a, A> where A: BuilderArena { pub fn get(self, index: u32) -> Result> { assert!(index < self.len()); self.builder.get_pointer_element(index).get_data(None) @@ -124,18 +116,20 @@ impl <'a> Builder<'a> { } -impl <'a> crate::traits::SetPointerBuilder> for Reader<'a> { - fn set_pointer_builder<'b>(pointer: crate::private::layout::PointerBuilder<'b>, - value: Reader<'a>, - canonicalize: bool) -> Result<()> { +impl <'a, A> crate::traits::SetPointerBuilder for Reader<'a, A> where A: ReaderArena { + fn set_pointer_builder<'b, B>(pointer: crate::private::layout::PointerBuilder<&'b mut B>, + value: Reader<'a, A>, + canonicalize: bool) -> Result<()> + where B: BuilderArena + { pointer.set_list(&value.reader, canonicalize)?; Ok(()) } } -impl <'a> ::core::iter::IntoIterator for Reader<'a> { +impl <'a, A> ::core::iter::IntoIterator for Reader<'a, A> where A: ReaderArena { type Item = Result>; - type IntoIter = ListIter, Self::Item>; + type IntoIter = ListIter, Self::Item>; fn into_iter(self) -> Self::IntoIter { self.iter() diff --git a/capnp/src/enum_list.rs b/capnp/src/enum_list.rs index ed825efbc..3d650805b 100644 --- a/capnp/src/enum_list.rs +++ b/capnp/src/enum_list.rs @@ -23,6 +23,7 @@ use crate::traits::{FromPointerReader, FromPointerBuilder, ToU16, FromU16, ListIter, IndexMove}; +use crate::private::arena::{ReaderArena, BuilderArena}; use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, TwoBytes, PrimitiveElement}; use crate::{NotInSchema, Result}; @@ -34,44 +35,40 @@ pub struct Owned { marker: PhantomData, } -impl <'a, T> crate::traits::Owned<'a> for Owned where T: FromU16 { - type Reader = Reader<'a, T>; - type Builder = Builder<'a, T>; +impl crate::traits::Owned for Owned where T: FromU16 { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A, T>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A, T>; } #[derive(Clone, Copy)] -pub struct Reader<'a, T> { +pub struct Reader<'a, A, T> { marker: PhantomData, - reader: ListReader<'a> + reader: ListReader<&'a A> } -impl <'a, T: FromU16> Reader<'a, T> { - pub fn new<'b>(reader: ListReader<'b>) -> Reader<'b, T> { - Reader::<'b, T> { reader: reader, marker: PhantomData } - } - +impl <'a, A, T: FromU16> Reader<'a, A, T> where A: ReaderArena { pub fn len(&self) -> u32 { self.reader.len() } - pub fn iter(self) -> ListIter, ::core::result::Result>{ + pub fn iter(self) -> ListIter, ::core::result::Result>{ let l = self.len(); ListIter::new(self, l) } } -impl <'a, T : FromU16> FromPointerReader<'a> for Reader<'a, T> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A, T : FromU16> FromPointerReader<'a, A> for Reader<'a, A, T> where A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Reader { reader: reader.get_list(TwoBytes, default)?, marker: PhantomData }) } } -impl <'a, T: FromU16> IndexMove> for Reader<'a, T>{ +impl <'a, A, T: FromU16> IndexMove> for Reader<'a, A, T> where A: ReaderArena { fn index_move(&self, index: u32) -> ::core::result::Result { self.get(index) } } -impl <'a, T : FromU16> Reader<'a, T> { +impl <'a, A, T: FromU16> Reader<'a, A, T> where A: ReaderArena { pub fn get(&self, index: u32) -> ::core::result::Result { assert!(index < self.len()); let result: u16 = PrimitiveElement::get(&self.reader, index); @@ -79,25 +76,21 @@ impl <'a, T : FromU16> Reader<'a, T> { } } -impl <'a, T> crate::traits::IntoInternalListReader<'a> for Reader<'a, T> where T: PrimitiveElement { - fn into_internal_list_reader(self) -> ListReader<'a> { +impl <'a, A, T> crate::traits::IntoInternalListReader<'a, A> for Reader<'a, A, T> where A: ReaderArena, T: PrimitiveElement { + fn into_internal_list_reader(self) -> ListReader<&'a A> { self.reader } } -pub struct Builder<'a, T> { +pub struct Builder<'a, A, T> { marker: PhantomData, - builder: ListBuilder<'a> + builder: ListBuilder<&'a mut A> } -impl <'a, T : ToU16 + FromU16> Builder<'a, T> { - pub fn new(builder: ListBuilder<'a>) -> Builder<'a, T> { - Builder { builder: builder, marker: PhantomData } - } - +impl <'a, A, T : ToU16 + FromU16> Builder<'a, A, T> where A: BuilderArena { pub fn len(&self) -> u32 { self.builder.len() } - pub fn into_reader(self) -> Reader<'a, T> { + pub fn into_reader(self) -> Reader<'a, A, T> { Reader { reader: self.builder.into_reader(), marker: PhantomData, } } @@ -107,40 +100,40 @@ impl <'a, T : ToU16 + FromU16> Builder<'a, T> { } } -impl <'a, T : FromU16> FromPointerBuilder<'a> for Builder<'a, T> { - fn init_pointer(builder: PointerBuilder<'a>, size: u32) -> Builder<'a, T> { +impl <'a, A, T: FromU16> FromPointerBuilder<'a, A> for Builder<'a, A, T> where A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, size: u32) -> Builder<'a, A, T> { Builder { builder: builder.init_list(TwoBytes, size), marker: PhantomData } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Builder { builder: builder.get_list(TwoBytes, default)?, marker: PhantomData }) } } -impl <'a, T : ToU16 + FromU16> Builder<'a, T> { +impl <'a, A, T: ToU16 + FromU16> Builder<'a, A, T> where A: BuilderArena { pub fn get(&self, index: u32) -> ::core::result::Result { assert!(index < self.len()); let result: u16 = PrimitiveElement::get_from_builder(&self.builder, index); FromU16::from_u16(result) } - pub fn reborrow<'b>(&'b self) -> Builder<'b, T> { - Builder { .. *self } + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A, T> { + Builder { builder: self.builder.reborrow(), marker: PhantomData } } } -impl <'a, T> crate::traits::SetPointerBuilder> for Reader<'a, T> { - fn set_pointer_builder<'b>(pointer: crate::private::layout::PointerBuilder<'b>, - value: Reader<'a, T>, - canonicalize: bool) -> Result<()> { +impl <'a, A, T> crate::traits::SetPointerBuilder for Reader<'a, A, T> where A: ReaderArena { + fn set_pointer_builder<'b, B>(pointer: crate::private::layout::PointerBuilder<&'b mut B>, + value: Reader<'a, A, T>, + canonicalize: bool) -> Result<()> where B: BuilderArena { pointer.set_list(&value.reader, canonicalize) } } -impl <'a, T: FromU16> ::core::iter::IntoIterator for Reader<'a, T> { +impl <'a, A, T: FromU16> ::core::iter::IntoIterator for Reader<'a, A, T> where A: ReaderArena { type Item = ::core::result::Result; - type IntoIter = ListIter, Self::Item>; + type IntoIter = ListIter, Self::Item>; fn into_iter(self) -> Self::IntoIter { self.iter() diff --git a/capnp/src/lib.rs b/capnp/src/lib.rs index 608a6e38b..02bef22a7 100644 --- a/capnp/src/lib.rs +++ b/capnp/src/lib.rs @@ -29,6 +29,9 @@ #![cfg_attr(feature = "rpc_try", feature(try_trait))] #![cfg_attr(not(feature = "std"), no_std)] +#![allow(incomplete_features)] +#![feature(generic_associated_types)] + #[macro_use] extern crate alloc; diff --git a/capnp/src/list_list.rs b/capnp/src/list_list.rs index 75b084b51..356b5f9f0 100644 --- a/capnp/src/list_list.rs +++ b/capnp/src/list_list.rs @@ -22,101 +22,97 @@ //! List of lists. use crate::traits::{FromPointerReader, FromPointerBuilder, ListIter, IndexMove}; + +use crate::private::arena::{ReaderArena, BuilderArena}; use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, Pointer}; use crate::Result; #[derive(Clone, Copy)] -pub struct Owned where T: for<'a> crate::traits::Owned<'a> { +pub struct Owned where T: crate::traits::Owned { marker: ::core::marker::PhantomData, } -impl<'a, T> crate::traits::Owned<'a> for Owned where T: for<'b> crate::traits::Owned<'b> { - type Reader = Reader<'a, T>; - type Builder = Builder<'a, T>; +impl crate::traits::Owned for Owned where T: crate::traits::Owned { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A, T>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A, T>; } -pub struct Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> { - marker: ::core::marker::PhantomData<>::Reader>, - reader: ListReader<'a> +pub struct Reader<'a, A, T> where T: crate::traits::Owned, A: ReaderArena { + marker: ::core::marker::PhantomData<::Reader<'a, A>>, + reader: ListReader<&'a A>, } -impl <'a, T> Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> { - pub fn new<'b>(reader: ListReader<'b>) -> Reader<'b, T> { - Reader::<'b, T> { reader: reader, marker: ::core::marker::PhantomData } - } - +impl <'a, A, T> Reader<'a, A, T> where T: crate::traits::Owned, A: ReaderArena { pub fn len(&self) -> u32 { self.reader.len() } - pub fn iter(self) -> ListIter, Result<>::Reader>> { + pub fn iter(self) -> ListIter, Result<::Reader<'a, A>>> { ListIter::new(self, self.len()) } } -impl <'a, T> Clone for Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> { - fn clone(&self) -> Reader<'a, T> { +impl <'a, A, T> Clone for Reader<'a, A, T> where T: crate::traits::Owned, A: ReaderArena { + fn clone(&self) -> Reader<'a, A, T> { Reader { marker : self.marker, reader : self.reader } } } -impl <'a, T> Copy for Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> {} +impl <'a, A, T> Copy for Reader<'a, A, T> where T: crate::traits::Owned, A: ReaderArena {} -impl <'a, T> IndexMove>::Reader>> for Reader<'a, T> -where T: for<'b> crate::traits::Owned<'b> { - fn index_move(&self, index : u32) -> Result<>::Reader> { +impl <'a, A, T> IndexMove::Reader<'a, A>>> for Reader<'a, A, T> +where T: crate::traits::Owned, + A: ReaderArena +{ + fn index_move(&self, index: u32) -> Result<::Reader<'a, A>> { self.get(index) } } -impl <'a, T> FromPointerReader<'a> for Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A, T> FromPointerReader<'a, A> for Reader<'a, A, T> where T: crate::traits::Owned, A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Reader { reader: reader.get_list(Pointer, default)?, marker: ::core::marker::PhantomData }) } } -impl <'a, T> Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> { - pub fn get(self, index: u32) -> Result<>::Reader> { - assert!(index < self.len()); - FromPointerReader::get_from_pointer(&self.reader.get_pointer_element(index), None) +impl <'a, A, T> Reader<'a, A, T> where T: crate::traits::Owned, A: ReaderArena { + pub fn get(self, index: u32) -> Result<::Reader<'a, A>> { + assert!(index < self.len()); + FromPointerReader::get_from_pointer(self.reader.get_pointer_element(index), None) } } -pub struct Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> { +pub struct Builder<'a, A, T> where T: crate::traits::Owned, A: BuilderArena { marker: ::core::marker::PhantomData, - builder: ListBuilder<'a> + builder: ListBuilder<&'a mut A>, } -impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> { - pub fn new(builder: ListBuilder<'a>) -> Builder<'a, T> { - Builder { builder: builder, marker: ::core::marker::PhantomData } - } - +impl <'a, A, T> Builder<'a, A, T> where T: crate::traits::Owned, A: BuilderArena { pub fn len(&self) -> u32 { self.builder.len() } - pub fn into_reader(self) -> Reader<'a, T> { + pub fn into_reader(self) -> Reader<'a, A, T> { Reader { reader: self.builder.into_reader(), marker: ::core::marker::PhantomData } } } -impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> { - pub fn init(self, index: u32, size: u32) -> >::Builder { +impl <'a, A, T> Builder<'a, A, T> where T: crate::traits::Owned, A: BuilderArena { + pub fn init(self, index: u32, size: u32) -> ::Builder<'a, A> { FromPointerBuilder::init_pointer(self.builder.get_pointer_element(index), size) } } -impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> { - pub fn reborrow<'b>(&'b mut self) -> Builder<'b, T> { - Builder {builder: self.builder.borrow(), marker: ::core::marker::PhantomData} +impl <'a, A, T> Builder<'a, A, T> where T: crate::traits::Owned, A: BuilderArena { + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A, T> { + Builder {builder: self.builder.reborrow(), marker: ::core::marker::PhantomData} } } -impl <'a, T> FromPointerBuilder<'a> for Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> { - fn init_pointer(builder: PointerBuilder<'a>, size : u32) -> Builder<'a, T> { +impl <'a, A, T> FromPointerBuilder<'a, A> for Builder<'a, A, T> where T: crate::traits::Owned, A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, size: u32) -> Builder<'a, A, T> { Builder { marker: ::core::marker::PhantomData, builder: builder.init_list(Pointer, size) } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Builder { marker: ::core::marker::PhantomData, builder: builder.get_list(Pointer, default)? @@ -124,28 +120,32 @@ impl <'a, T> FromPointerBuilder<'a> for Builder<'a, T> where T: for<'b> crate::t } } -impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> { - pub fn get(self, index: u32) -> Result<>::Builder> { +impl <'a, A, T> Builder<'a, A, T> where T: crate::traits::Owned, A: BuilderArena { + pub fn get(self, index: u32) -> Result<::Builder<'a, A>> { assert!(index < self.len()); FromPointerBuilder::get_from_pointer(self.builder.get_pointer_element(index), None) } } -impl <'a, T> crate::traits::SetPointerBuilder> for Reader<'a, T> - where T: for<'b> crate::traits::Owned<'b> +impl <'a, A, T> crate::traits::SetPointerBuilder for Reader<'a, A, T> +where T: crate::traits::Owned, + A: ReaderArena { - fn set_pointer_builder<'b>(pointer: crate::private::layout::PointerBuilder<'b>, - value: Reader<'a, T>, - canonicalize: bool) -> Result<()> { + fn set_pointer_builder<'b, B>(pointer: crate::private::layout::PointerBuilder<&'b mut B>, + value: Reader<'a, A, T>, + canonicalize: bool) -> Result<()> + where B: BuilderArena + { pointer.set_list(&value.reader, canonicalize) } } -impl <'a, T> ::core::iter::IntoIterator for Reader<'a, T> - where T: for<'b> crate::traits::Owned<'b> +impl <'a, A, T> ::core::iter::IntoIterator for Reader<'a, A, T> +where T: crate::traits::Owned, + A: ReaderArena { - type Item = Result<>::Reader>; - type IntoIter = ListIter, Self::Item>; + type Item = Result<::Reader<'a, A>>; + type IntoIter = ListIter, Self::Item>; fn into_iter(self) -> Self::IntoIter { self.iter() diff --git a/capnp/src/message.rs b/capnp/src/message.rs index d09047583..b8d47050d 100644 --- a/capnp/src/message.rs +++ b/capnp/src/message.rs @@ -25,7 +25,7 @@ use alloc::vec::Vec; use core::convert::From; use crate::any_pointer; -use crate::private::arena::{BuilderArenaImpl, ReaderArenaImpl, BuilderArena, ReaderArena}; +use crate::private::arena::{BuilderArenaImpl, ReaderArenaImpl, ReadLimiterImpl, BuilderArena, ReaderArena}; use crate::private::layout; use crate::private::units::BYTES_PER_WORD; use crate::traits::{FromPointerReader, FromPointerBuilder, SetPointerBuilder, Owned}; @@ -151,28 +151,28 @@ impl <'b> ReaderSegments for [&'b [u8]] { } /// A container used to read a message. -pub struct Reader where S: ReaderSegments { - arena: ReaderArenaImpl, - nesting_limit: i32, +pub struct Reader where A: ReaderArena { + arena: A, } -impl Reader where S: ReaderSegments { - pub fn new(segments: S, options: ReaderOptions) -> Self { +impl Reader where A: ReaderArena { + pub fn new(segments: S, options: ReaderOptions) -> Reader> + where Align: crate::private::primitive::Alignment + { Reader { - arena: ReaderArenaImpl::new(segments, options), - nesting_limit: options.nesting_limit, + arena: ReaderArenaImpl::new::(segments, options), } } - fn get_root_internal<'a>(&'a self) -> Result> { + fn get_root_internal<'a>(&'a self) -> Result> { let (segment_start, _seg_len) = self.arena.get_segment(0)?; let pointer_reader = layout::PointerReader::get_root( - &self.arena, 0, segment_start, self.nesting_limit)?; + &self.arena, 0, segment_start, self.arena.nesting_limit())?; Ok(any_pointer::Reader::new(pointer_reader)) } /// Gets the root of the message, interpreting it as the given type. - pub fn get_root<'a, T: FromPointerReader<'a>>(&'a self) -> Result { + pub fn get_root<'a, T: FromPointerReader<'a, A>>(&'a self) -> Result { self.get_root_internal()?.get_as() } @@ -193,7 +193,7 @@ impl Reader where S: ReaderSegments { } let pointer_reader = layout::PointerReader::get_root( - &self.arena, 0, segment_start, self.nesting_limit)?; + &self.arena, 0, segment_start, self.arena.nesting_limit())?; let read_head = ::core::cell::Cell::new(unsafe {segment_start.offset(BYTES_PER_WORD as isize)}); let root_is_canonical = pointer_reader.is_canonical(&read_head)?; let all_words_consumed = @@ -218,22 +218,22 @@ impl Reader where S: ReaderSegments { Ok(result) } - pub fn into_typed Owned<'a>>(self) -> TypedReader { - TypedReader::new(self) - } +// pub fn into_typed(self) -> TypedReader { +// TypedReader::new(self) +// } } - +/* /// A message reader whose value is known to be of type `T`. pub struct TypedReader where S: ReaderSegments, - T: for<'a> Owned<'a> { + T: Owned { marker: ::core::marker::PhantomData, message: Reader, } impl TypedReader where S: ReaderSegments, - T : for<'a> Owned<'a> { + T : Owned { pub fn new(message: Reader) -> Self { TypedReader { @@ -242,7 +242,7 @@ impl TypedReader } } - pub fn get<'a> (&'a self) -> Result<>::Reader> { + pub fn get<'a> (&'a self) -> Result<::Reader<'a, ReaderArenaImpl>> { self.message.get_root() } @@ -253,7 +253,7 @@ impl TypedReader impl From> for TypedReader where S: ReaderSegments, - T: for<'a> Owned<'a> { + T: Owned { fn from(message: Reader) -> TypedReader { TypedReader::new(message) @@ -262,14 +262,14 @@ impl From> for TypedReader impl From> for TypedReader, T> where A: Allocator, - T: for<'a> Owned<'a> { + T: Owned { fn from(message: Builder) -> TypedReader, T> { let reader = message.into_reader(); reader.into_typed() } } - +*/ /// An object that allocates memory for a Cap'n Proto message as it is being built. pub unsafe trait Allocator { /// Allocates zeroed memory for a new segment, returning a pointer to the start of the segment @@ -317,7 +317,7 @@ impl Builder where A: Allocator { } } - fn get_root_internal<'a>(&'a mut self) -> any_pointer::Builder<'a> { + fn get_root_internal<'a>(&'a mut self) -> any_pointer::Builder<'a, BuilderArenaImpl> { if self.arena.len() == 0 { self.arena.allocate_segment(1).expect("allocate root pointer"); self.arena.allocate(0, 1).expect("allocate root pointer"); @@ -331,31 +331,31 @@ impl Builder where A: Allocator { } /// Initializes the root as a value of the given type. - pub fn init_root<'a, T: FromPointerBuilder<'a>>(&'a mut self) -> T { + pub fn init_root<'a, T: FromPointerBuilder<'a, BuilderArenaImpl>>(&'a mut self) -> T { let root = self.get_root_internal(); root.init_as() } /// Gets the root, interpreting it as the given type. - pub fn get_root<'a, T: FromPointerBuilder<'a>>(&'a mut self) -> Result { + pub fn get_root<'a, T: FromPointerBuilder<'a, BuilderArenaImpl>>(&'a mut self) -> Result { let root = self.get_root_internal(); root.get_as() } - pub fn get_root_as_reader<'a, T: FromPointerReader<'a>>(&'a self) -> Result { + pub fn get_root_as_reader<'a, T: FromPointerReader<'a, BuilderArenaImpl>>(&'a self) -> Result { if self.arena.len() == 0 { any_pointer::Reader::new(layout::PointerReader::new_default()).get_as() } else { let (segment_start, _segment_len) = self.arena.get_segment(0)?; let pointer_reader = layout::PointerReader::get_root( - self.arena.as_reader(), 0, segment_start, 0x7fffffff)?; + &self.arena, 0, segment_start, 0x7fffffff)?; let root = any_pointer::Reader::new(pointer_reader); root.get_as() } } /// Sets the root to a deep copy of the given value. - pub fn set_root>(&mut self, value: From) -> Result<()> { + pub fn set_root(&mut self, value: From) -> Result<()> { let root = self.get_root_internal(); root.set_as(value) } @@ -363,13 +363,13 @@ impl Builder where A: Allocator { /// Sets the root to a canonicalized version of `value`. If this was the first action taken /// on this `Builder`, then a subsequent call to `get_segments_for_output()` should return /// a single segment, containing the full canonicalized message. - pub fn set_root_canonical>(&mut self, value: From) -> Result<()> { + pub fn set_root_canonical(&mut self, value: From) -> Result<()> { if self.arena.len() == 0 { self.arena.allocate_segment(1).expect("allocate root pointer"); self.arena.allocate(0, 1).expect("allocate root pointer"); } let (seg_start, _seg_len) = self.arena.get_segment_mut(0); - let pointer = layout::PointerBuilder::get_root(&self.arena, 0, seg_start); + let pointer = layout::PointerBuilder::get_root(&mut self.arena, 0, seg_start); SetPointerBuilder::set_pointer_builder(pointer, value, true)?; assert_eq!(self.get_segments_for_output().len(), 1); Ok(()) @@ -378,14 +378,14 @@ impl Builder where A: Allocator { pub fn get_segments_for_output<'a>(&'a self) -> OutputSegments<'a> { self.arena.get_segments_for_output() } - +/* pub fn into_reader(self) -> Reader> { Reader::new(self, ReaderOptions { traversal_limit_in_words: u64::max_value(), nesting_limit: i32::max_value() }) } - +*/ pub fn into_allocator(self) -> A { self.arena.into_allocator() } diff --git a/capnp/src/primitive_list.rs b/capnp/src/primitive_list.rs index 481855cc9..1d199938a 100644 --- a/capnp/src/primitive_list.rs +++ b/capnp/src/primitive_list.rs @@ -24,6 +24,7 @@ use core::{marker}; use crate::traits::{FromPointerReader, FromPointerBuilder, IndexMove, ListIter}; +use crate::private::arena::{BuilderArena, ReaderArena}; use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, PrimitiveElement}; use crate::Result; @@ -33,69 +34,61 @@ pub struct Owned { marker: marker::PhantomData, } -impl <'a, T> crate::traits::Owned<'a> for Owned where T: PrimitiveElement { - type Reader = Reader<'a, T>; - type Builder = Builder<'a, T>; +impl crate::traits::Owned for Owned where T: PrimitiveElement { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A, T>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A, T>; } #[derive(Clone, Copy)] -pub struct Reader<'a, T> where T: PrimitiveElement { +pub struct Reader<'a, A, T> where T: PrimitiveElement { marker: marker::PhantomData, - reader: ListReader<'a> + reader: ListReader<&'a A> } -impl <'a, T: PrimitiveElement> Reader<'a, T> { - pub fn new<'b>(reader: ListReader<'b>) -> Reader<'b, T> { - Reader::<'b, T> { reader: reader, marker: marker::PhantomData } - } - +impl <'a, A, T: PrimitiveElement> Reader<'a, A, T> where A: ReaderArena { pub fn len(&self) -> u32 { self.reader.len() } - pub fn iter(self) -> ListIter, T>{ + pub fn iter(self) -> ListIter{ let l = self.len(); ListIter::new(self, l) } } -impl <'a, T: PrimitiveElement> FromPointerReader<'a> for Reader<'a, T> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A, T: PrimitiveElement> FromPointerReader<'a, A> for Reader<'a, A, T> where A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Reader { reader: reader.get_list(T::element_size(), default)?, marker: marker::PhantomData }) } } -impl <'a, T: PrimitiveElement> IndexMove for Reader<'a, T>{ +impl <'a, A, T: PrimitiveElement> IndexMove for Reader<'a, A, T> where A: ReaderArena { fn index_move(&self, index: u32) -> T { self.get(index) } } -impl <'a, T: PrimitiveElement> Reader<'a, T> { +impl <'a, A, T: PrimitiveElement> Reader<'a, A, T> where A: ReaderArena { pub fn get(&self, index: u32) -> T { assert!(index < self.len()); PrimitiveElement::get(&self.reader, index) } } -impl <'a, T> crate::traits::IntoInternalListReader<'a> for Reader<'a, T> where T: PrimitiveElement { - fn into_internal_list_reader(self) -> ListReader<'a> { +impl <'a, A, T> crate::traits::IntoInternalListReader<'a, A> for Reader<'a, A, T> where T: PrimitiveElement { + fn into_internal_list_reader(self) -> ListReader<&'a A> { self.reader } } -pub struct Builder<'a, T> where T: PrimitiveElement { +pub struct Builder<'a, A, T> where T: PrimitiveElement { marker: marker::PhantomData, - builder: ListBuilder<'a> + builder: ListBuilder<&'a mut A> } -impl <'a, T> Builder<'a, T> where T: PrimitiveElement { - pub fn new(builder: ListBuilder<'a>) -> Builder<'a, T> { - Builder { builder: builder, marker: marker::PhantomData } - } - +impl <'a, A, T> Builder<'a, A, T> where T: PrimitiveElement, A: BuilderArena { pub fn len(&self) -> u32 { self.builder.len() } - pub fn into_reader(self) -> Reader<'a, T> { + pub fn into_reader(self) -> Reader<'a, A, T> { Reader { marker: marker::PhantomData, reader: self.builder.into_reader(), @@ -107,43 +100,48 @@ impl <'a, T> Builder<'a, T> where T: PrimitiveElement { } } -impl <'a, T: PrimitiveElement> FromPointerBuilder<'a> for Builder<'a, T> { - fn init_pointer(builder: PointerBuilder<'a>, size: u32) -> Builder<'a, T> { +impl <'a, A, T: PrimitiveElement> FromPointerBuilder<'a, A> for Builder<'a, A, T> where A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, size: u32) -> Builder<'a, A, T> { Builder { builder: builder.init_list(T::element_size(), size), marker: marker::PhantomData } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Builder { builder: builder.get_list(T::element_size(), default)?, marker: marker::PhantomData }) } } -impl <'a, T : PrimitiveElement> Builder<'a, T> { +impl <'a, A, T: PrimitiveElement> Builder<'a, A, T> where A: BuilderArena { pub fn get(&self, index: u32) -> T { assert!(index < self.len()); PrimitiveElement::get_from_builder(&self.builder, index) } - pub fn reborrow<'b>(&'b self) -> Builder<'b, T> { - Builder { .. *self } + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A, T> { + Builder { builder: self.builder.reborrow(), + .. *self } } } -impl <'a, T> crate::traits::SetPointerBuilder> for Reader<'a, T> - where T: PrimitiveElement +impl <'a, A, T> crate::traits::SetPointerBuilder for Reader<'a, A, T> +where T: PrimitiveElement, + A: ReaderArena { - fn set_pointer_builder<'b>(pointer: PointerBuilder<'b>, - value: Reader<'a, T>, - canonicalize: bool) -> Result<()> { + fn set_pointer_builder<'b, B>(pointer: PointerBuilder<&'b mut B>, + value: Reader<'a, A, T>, + canonicalize: bool) -> Result<()> + where B: BuilderArena + { pointer.set_list(&value.reader, canonicalize) } } -impl <'a, T> ::core::iter::IntoIterator for Reader<'a, T> - where T: PrimitiveElement +impl <'a, A, T> ::core::iter::IntoIterator for Reader<'a, A, T> +where T: PrimitiveElement, + A: ReaderArena { type Item = T; - type IntoIter = ListIter, Self::Item>; + type IntoIter = ListIter, Self::Item>; fn into_iter(self) -> Self::IntoIter { self.iter() diff --git a/capnp/src/private/arena.rs b/capnp/src/private/arena.rs index 73a0ece5e..8b8f19390 100644 --- a/capnp/src/private/arena.rs +++ b/capnp/src/private/arena.rs @@ -19,7 +19,7 @@ // THE SOFTWARE. use alloc::vec::Vec; -use core::cell::{Cell, RefCell}; +use core::cell::{Cell}; use core::slice; use core::u64; @@ -30,17 +30,22 @@ use crate::{Error, OutputSegments, Result}; pub type SegmentId = u32; -pub struct ReadLimiter { +pub trait ReadLimiter { + fn can_read(&self, amount: u64) -> Result<()>; +} + +pub struct ReadLimiterImpl { pub limit: Cell, } -impl ReadLimiter { - pub fn new(limit: u64) -> ReadLimiter { - ReadLimiter { limit: Cell::new(limit) } +impl ReadLimiterImpl { + pub fn new(limit: u64) -> Self { + ReadLimiterImpl { limit: Cell::new(limit) } } +} - #[inline] - pub fn can_read(&self, amount: u64) -> Result<()> { +impl ReadLimiter for ReadLimiterImpl { + fn can_read(&self, amount: u64) -> Result<()> { let current = self.limit.get(); if amount > current { Err(Error::failed(format!("read limit exceeded"))) @@ -52,6 +57,8 @@ impl ReadLimiter { } pub trait ReaderArena { + type Alignment: crate::private::primitive::Alignment; + // return pointer to start of segment, and number of words in that segment fn get_segment(&self, id: u32) -> Result<(*const u8, u32)>; @@ -59,25 +66,32 @@ pub trait ReaderArena { fn contains_interval(&self, segment_id: u32, start: *const u8, size: usize) -> Result<()>; fn amplified_read(&self, virtual_amount: u64) -> Result<()>; + fn nesting_limit(&self) -> i32; + // TODO(version 0.9): Consider putting extract_cap(), inject_cap(), drop_cap() here // and on message::Reader. Then we could get rid of Imbue and ImbueMut, and // layout::StructReader, layout::ListReader, etc. could drop their `cap_table` fields. } -pub struct ReaderArenaImpl { +pub struct ReaderArenaImpl { + alignment: core::marker::PhantomData, segments: S, - read_limiter: ReadLimiter, + read_limiter: L, + nesting_limit: i32, } -impl ReaderArenaImpl where S: ReaderSegments { - pub fn new(segments: S, - options: message::ReaderOptions) - -> Self +impl ReaderArenaImpl where S: ReaderSegments { + pub fn new(segments: S, + options: message::ReaderOptions) + -> ReaderArenaImpl + where A: crate::private::primitive::Alignment { - let limiter = ReadLimiter::new(options.traversal_limit_in_words); + let limiter = ReadLimiterImpl::new(options.traversal_limit_in_words); ReaderArenaImpl { + alignment: core::marker::PhantomData, segments: segments, read_limiter: limiter, + nesting_limit: options.nesting_limit, } } @@ -86,7 +100,9 @@ impl ReaderArenaImpl where S: ReaderSegments { } } -impl ReaderArena for ReaderArenaImpl where S: ReaderSegments { +impl ReaderArena for ReaderArenaImpl where S: ReaderSegments, L: ReadLimiter, A: crate::private::primitive::Alignment { + type Alignment = A; + fn get_segment<'a>(&'a self, id: u32) -> Result<(*const u8, u32)> { match self.segments.get_segment(id) { Some(seg) => { @@ -107,16 +123,16 @@ impl ReaderArena for ReaderArenaImpl where S: ReaderSegments { } fn check_offset(&self, segment_id: u32, start: *const u8, offset_in_words: i32) -> Result<*const u8> { + let offset: i64 = offset_in_words as i64 * BYTES_PER_WORD as i64; let (segment_start, segment_len) = self.get_segment(segment_id)?; let this_start: usize = segment_start as usize; let this_size: usize = segment_len as usize * BYTES_PER_WORD; - let offset: i64 = offset_in_words as i64 * BYTES_PER_WORD as i64; let start_idx = start as usize; if start_idx < this_start || ((start_idx - this_start) as i64 + offset) as usize > this_size { - Err(Error::failed(format!("message contained out-of-bounds pointer"))) - } else { - unsafe { Ok(start.offset(offset as isize)) } + return Err(Error::failed(format!("message contained out-of-bounds pointer"))); } + + unsafe { Ok(start.offset(offset as isize)) } } fn contains_interval(&self, id: u32, start: *const u8, size_in_words: usize) -> Result<()> { @@ -136,20 +152,16 @@ impl ReaderArena for ReaderArenaImpl where S: ReaderSegments { fn amplified_read(&self, virtual_amount: u64) -> Result<()> { self.read_limiter.can_read(virtual_amount) } + + fn nesting_limit(&self) -> i32 { + self.nesting_limit + } } pub trait BuilderArena: ReaderArena { - // These methods all take an immutable &self because otherwise a StructBuilder<'a> - // would need a `&'a mut BuilderArena` and `StructBuilder::borrow()` would - // have lifetime issues. (If `'a: 'b`, then a `&'a (BuilderArena + 'a)` can be - // converted to a `&'b (BuilderArena + 'b)`, but a `&'a mut (BuilderArena + 'a)` - // *cannot* be converted to a `&'b mut (BuilderArena + 'b)`. See some discussion here: - // https://botbot.me/mozilla/rust/2017-01-31/?msg=80228117&page=19 .) - fn allocate(&self, segment_id: u32, amount: WordCount32) -> Option; - fn allocate_anywhere(&self, amount: u32) -> (SegmentId, u32); - fn get_segment_mut(&self, id: u32) -> (*mut u8, u32); - - fn as_reader<'a>(&'a self) -> &'a dyn ReaderArena; + fn allocate(&mut self, segment_id: u32, amount: WordCount32) -> Option; + fn allocate_anywhere(&mut self, amount: u32) -> (SegmentId, u32); + fn get_segment_mut(&mut self, id: u32) -> (*mut u8, u32); } struct BuilderSegment { @@ -158,35 +170,24 @@ struct BuilderSegment { allocated: u32, // in words } -pub struct BuilderArenaImplInner where A: Allocator { +pub struct BuilderArenaImpl where A: Allocator { allocator: Option, // None if has already be deallocated. // TODO(perf): Try using smallvec to avoid heap allocations in the single-segment case? segments: Vec, } -pub struct BuilderArenaImpl where A: Allocator { - inner: RefCell> -} - impl BuilderArenaImpl where A: Allocator { pub fn new(allocator: A) -> Self { BuilderArenaImpl { - inner: RefCell::new(BuilderArenaImplInner { - allocator: Some(allocator), - segments: Vec::new(), - }), + allocator: Some(allocator), + segments: Vec::new(), } } - pub fn allocate_segment(&self, minimum_size: u32) -> Result<()> { - self.inner.borrow_mut().allocate_segment(minimum_size) - } - pub fn get_segments_for_output<'a>(&'a self) -> OutputSegments<'a> { - let reff = self.inner.borrow(); - if reff.segments.len() == 1 { - let seg = &reff.segments[0]; + if self.segments.len() == 1 { + let seg = &self.segments[0]; // The user must mutably borrow the `message::Builder` to be able to modify segment memory. // No such borrow will be possible while `self` is still immutably borrowed from this method, @@ -194,8 +195,8 @@ impl BuilderArenaImpl where A: Allocator { let slice = unsafe { slice::from_raw_parts(seg.ptr as *const _, seg.allocated as usize * BYTES_PER_WORD) }; OutputSegments::SingleSegment([slice]) } else { - let mut v = Vec::with_capacity(reff.segments.len()); - for ref seg in &reff.segments { + let mut v = Vec::with_capacity(self.segments.len()); + for ref seg in &self.segments { // See safety argument in above branch. let slice = unsafe { slice::from_raw_parts(seg.ptr as *const _, seg.allocated as usize * BYTES_PER_WORD) }; v.push(slice); @@ -205,20 +206,20 @@ impl BuilderArenaImpl where A: Allocator { } pub fn len(&self) -> usize { - self.inner.borrow().segments.len() + self.segments.len() } - pub fn into_allocator(self) -> A { - let mut inner = self.inner.into_inner(); - inner.deallocate_all(); - inner.allocator.take().unwrap() + pub fn into_allocator(mut self) -> A { + self.deallocate_all(); + self.allocator.take().unwrap() } } impl ReaderArena for BuilderArenaImpl where A: Allocator { + type Alignment = crate::private::primitive::Unaligned; // TODO + fn get_segment(&self, id: u32) -> Result<(*const u8, u32)> { - let borrow = self.inner.borrow(); - let seg = &borrow.segments[id as usize]; + let seg = &self.segments[id as usize]; Ok((seg.ptr, seg.allocated)) } @@ -233,10 +234,14 @@ impl ReaderArena for BuilderArenaImpl where A: Allocator { fn amplified_read(&self, _virtual_amount: u64) -> Result<()> { Ok(()) } + + fn nesting_limit(&self) -> i32 { + 0x7fffffff + } } -impl BuilderArenaImplInner where A: Allocator { - fn allocate_segment(&mut self, minimum_size: WordCount32) -> Result<()> { +impl BuilderArenaImpl where A: Allocator { + pub fn allocate_segment(&mut self, minimum_size: WordCount32) -> Result<()> { let seg = match self.allocator { Some(ref mut a) => a.allocate_segment(minimum_size), None => unreachable!(), @@ -288,24 +293,20 @@ impl BuilderArenaImplInner where A: Allocator { } impl BuilderArena for BuilderArenaImpl where A: Allocator { - fn allocate(&self, segment_id: u32, amount: WordCount32) -> Option { - self.inner.borrow_mut().allocate(segment_id, amount) - } - - fn allocate_anywhere(&self, amount: u32) -> (SegmentId, u32) { - self.inner.borrow_mut().allocate_anywhere(amount) + fn allocate(&mut self, segment_id: u32, amount: WordCount32) -> Option { + self.allocate(segment_id, amount) } - fn get_segment_mut(&self, id: u32) -> (*mut u8, u32) { - self.inner.borrow_mut().get_segment_mut(id) + fn allocate_anywhere(&mut self, amount: u32) -> (SegmentId, u32) { + self.allocate_anywhere(amount) } - fn as_reader<'a>(&'a self) -> &'a dyn ReaderArena { - self + fn get_segment_mut(&mut self, id: u32) -> (*mut u8, u32) { + self.get_segment_mut(id) } } -impl Drop for BuilderArenaImplInner where A: Allocator { +impl Drop for BuilderArenaImpl where A: Allocator { fn drop(&mut self) { self.deallocate_all() } @@ -314,6 +315,8 @@ impl Drop for BuilderArenaImplInner where A: Allocator { pub struct NullArena; impl ReaderArena for NullArena { + type Alignment = crate::private::primitive::Unaligned; + fn get_segment(&self, _id: u32) -> Result<(*const u8, u32)> { Err(Error::failed(format!("tried to read from null arena"))) } @@ -329,23 +332,8 @@ impl ReaderArena for NullArena { fn amplified_read(&self, _virtual_amount: u64) -> Result<()> { Ok(()) } -} -impl BuilderArena for NullArena { - fn allocate(&self, _segment_id: u32, _amount: WordCount32) -> Option { - None - } - - fn allocate_anywhere(&self, _amount: u32) -> (SegmentId, u32) { - panic!("tried to allocate from a null arena") - } - - fn get_segment_mut(&self, _id: u32) -> (*mut u8, u32) { - (core::ptr::null_mut(), 0) - } - - fn as_reader<'a>(&'a self) -> &'a dyn ReaderArena { - self + fn nesting_limit(&self) -> i32 { + 0x7fffffff } } - diff --git a/capnp/src/private/capability.rs b/capnp/src/private/capability.rs index 3ca51e718..b8178144b 100644 --- a/capnp/src/private/capability.rs +++ b/capnp/src/private/capability.rs @@ -24,28 +24,29 @@ use alloc::vec::Vec; use crate::any_pointer; use crate::MessageSize; -use crate::capability::{Params, Promise, Request, RemotePromise, Results}; +use crate::capability::{Params, Promise, Request, Results}; pub trait ResponseHook { - fn get<'a>(&'a self) -> crate::Result>; +// fn get<'a>(&'a self) -> crate::Result>; } pub trait RequestHook { - fn get<'a>(&'a mut self) -> any_pointer::Builder<'a>; +// fn get<'a>(&'a mut self) -> any_pointer::Builder<'a>; fn get_brand(&self) -> usize; - fn send(self: Box) -> RemotePromise; +// fn send(self: Box) -> RemotePromise; fn tail_send(self: Box) -> Option<(u32, crate::capability::Promise<(), crate::Error>, Box)>; } pub trait ClientHook { fn add_ref(&self) -> Box; + fn new_call(&self, interface_id: u64, method_id: u16, size_hint: Option) -> Request; - + /* fn call(&self, interface_id: u64, method_id: u16, params: Box, results: Box) -> crate::capability::Promise<(), crate::Error>; @@ -68,6 +69,7 @@ pub trait ClientHook { /// Repeatedly calls whenMoreResolved() until it returns nullptr. fn when_resolved(&self) -> Promise<(), crate::Error>; +*/ } impl Clone for Box { @@ -77,7 +79,7 @@ impl Clone for Box { } pub trait ResultsHook { - fn get<'a>(&'a mut self) -> crate::Result>; +// fn get<'a>(&'a mut self) -> crate::Result>; fn allow_cancellation(&self); fn tail_call(self: Box, request: Box) -> Promise<(), crate::Error>; fn direct_tail_call(self: Box, request: Box) -> @@ -85,7 +87,7 @@ pub trait ResultsHook { } pub trait ParamsHook { - fn get<'a>(&'a self) -> crate::Result>; +// fn get<'a>(&'a self) -> crate::Result>; } // Where should this live? diff --git a/capnp/src/private/layout.rs b/capnp/src/private/layout.rs index 4d488e8af..f00ed4296 100644 --- a/capnp/src/private/layout.rs +++ b/capnp/src/private/layout.rs @@ -30,7 +30,7 @@ use crate::text; use crate::private::capability::{ClientHook}; use crate::private::arena::{BuilderArena, ReaderArena, NullArena, SegmentId}; use crate::private::mask::Mask; -use crate::private::primitive::{Primitive, WireValue}; +use crate::private::primitive::{Alignment, Primitive, WireValue}; use crate::private::units::*; use crate::private::zero; use crate::{MessageSize, Result}; @@ -130,19 +130,20 @@ impl WirePointerKind { #[repr(C)] pub struct WirePointer { - offset_and_kind: WireValue, - upper32bits: WireValue, + offset_and_kind: WireValue, + upper32bits: WireValue, } +/* +TODO #[test] -#[cfg(feature = "unaligned")] fn wire_pointer_align() { // We cast *u8 to *WirePointer, so we need to make sure its alignment allows that. - assert_eq!(core::mem::align_of::(), 1); + assert_eq!(core::mem::align_of::>(), 1); } +*/ impl WirePointer { - #[inline] pub fn kind(&self) -> WirePointerKind { WirePointerKind::from(self.offset_and_kind.get() as u8 & 3) @@ -165,10 +166,15 @@ impl WirePointer { } #[inline] - pub fn target_from_segment(&self, arena: &dyn ReaderArena, segment_id: u32) -> Result<*const u8> { + pub fn target_from_segment(&self, arena_and_segment: Option>) -> Result<*const u8> + where A: ReaderArena + { let this_addr: *const u8 = self as *const _ as *const _; let offset = 1 + ((self.offset_and_kind.get() as i32) >> 2); - arena.check_offset(segment_id, this_addr, offset) + match arena_and_segment { + Some(ref aas) => aas.arena.check_offset(aas.segment_id, this_addr, offset), + None => unsafe { Ok(this_addr.offset((offset as usize * BYTES_PER_WORD)as isize)) }, + } } #[inline] @@ -318,6 +324,12 @@ impl WirePointer { } } +#[derive(Clone, Copy)] +pub struct ArenaAndSegment { + arena: A, + segment_id: u32, +} + mod wire_helpers { use alloc::boxed::Box; use alloc::string::ToString; @@ -326,6 +338,7 @@ mod wire_helpers { use crate::private::capability::ClientHook; use crate::private::arena::*; use crate::private::layout::{ + ArenaAndSegment, CapTableBuilder, CapTableReader, ElementSize, ListBuilder, ListReader, StructBuilder, StructReader, StructSize, WirePointer, WirePointerKind}; use crate::private::layout::{data_bits_per_element, pointers_per_element}; @@ -364,25 +377,35 @@ mod wire_helpers { } #[inline] - pub fn bounds_check(arena: &dyn ReaderArena, - segment_id: u32, - start: *const u8, size_in_words: usize, - _kind: WirePointerKind) -> Result<()> { - arena.contains_interval(segment_id, start, size_in_words) + pub fn bounds_check(arena_and_segment: Option>, + start: *const u8, size_in_words: usize, + _kind: WirePointerKind) -> Result<()> + where A: ReaderArena + { + match arena_and_segment { + Some(aas) => aas.arena.contains_interval(aas.segment_id, start, size_in_words), + None => Ok(()), + } } #[inline] - pub fn amplified_read(arena: &dyn ReaderArena, - virtual_amount: u64) -> Result<()> { - arena.amplified_read(virtual_amount) + pub fn amplified_read(arena_and_segment: Option>, + virtual_amount: u64) -> Result<()> + where A: ReaderArena + { + match arena_and_segment { + Some(aas) => aas.arena.amplified_read(virtual_amount), + None => Ok(()), + } } #[inline] - pub unsafe fn allocate( - arena: &dyn BuilderArena, + pub unsafe fn allocate( + arena: &mut A, reff: *mut WirePointer, segment_id: u32, amount: WordCount32, kind: WirePointerKind) -> (*mut u8, *mut WirePointer, u32) + where A: BuilderArena { let is_null = (*reff).is_null(); if !is_null { @@ -429,11 +452,12 @@ mod wire_helpers { } #[inline] - pub unsafe fn follow_builder_fars( - arena: &dyn BuilderArena, + pub unsafe fn follow_builder_fars( + arena: &mut A, reff: *mut WirePointer, ref_target: *mut u8, segment_id: u32) -> Result<(*mut u8, *mut WirePointer, u32)> + where A: BuilderArena { // If `ref` is a far pointer, follow it. On return, `ref` will have been updated to point at // a WirePointer that contains the type information about the target object, and a pointer @@ -471,44 +495,50 @@ mod wire_helpers { /// - the resolved WirePointer, whose kind is something other than WirePointerKind::Far /// - the segment on which the pointed-to object lives #[inline] - pub unsafe fn follow_fars( - arena: &dyn ReaderArena, - reff: *const WirePointer, - segment_id: u32) - -> Result<(*const u8, *const WirePointer, u32)> + pub unsafe fn follow_fars( + arena_and_segment: Option>, + reff: *const WirePointer) + -> Result<(*const u8, *const WirePointer, Option>)> + where A: ReaderArena { if (*reff).kind() == WirePointerKind::Far { let far_segment_id = (*reff).far_segment_id(); - let (seg_start, _seg_len) = arena.get_segment(far_segment_id)?; - let ptr = seg_start.offset((*reff).far_position_in_segment() as isize * BYTES_PER_WORD as isize); + if let Some(ArenaAndSegment { arena, segment_id: _ } ) = arena_and_segment { + let (seg_start, _seg_len) = arena.get_segment(far_segment_id)?; + let ptr = seg_start.offset((*reff).far_position_in_segment() as isize * BYTES_PER_WORD as isize); - let pad_words: usize = if (*reff).is_double_far() { 2 } else { 1 }; - bounds_check(arena, far_segment_id, ptr, pad_words, WirePointerKind::Far)?; + let pad_words: usize = if (*reff).is_double_far() { 2 } else { 1 }; + let new_arena_and_segment = Some(ArenaAndSegment { arena, segment_id: far_segment_id}); + bounds_check(new_arena_and_segment, ptr, pad_words, WirePointerKind::Far)?; - let pad: *const WirePointer = ptr as *const _; + let pad: *const WirePointer = ptr as *const _; - if !(*reff).is_double_far() { - Ok(((*pad).target_from_segment(arena, far_segment_id)?, pad, far_segment_id)) + if !(*reff).is_double_far() { + Ok(((*pad).target_from_segment(new_arena_and_segment)?, pad, new_arena_and_segment)) + } else { + // Landing pad is another far pointer. It is followed by a tag describing the + // pointed-to object. + + let tag = pad.offset(1); + let double_far_segment_id = (*pad).far_segment_id(); + let (segment_start, _segment_len) = arena.get_segment(double_far_segment_id)?; + let ptr = segment_start.offset((*pad).far_position_in_segment() as isize * BYTES_PER_WORD as isize); + Ok((ptr, tag, Some(ArenaAndSegment {arena, segment_id: double_far_segment_id }))) + } } else { - // Landing pad is another far pointer. It is followed by a tag describing the - // pointed-to object. - - let tag = pad.offset(1); - let double_far_segment_id = (*pad).far_segment_id(); - let (segment_start, _segment_len) = arena.get_segment(double_far_segment_id)?; - let ptr = segment_start.offset((*pad).far_position_in_segment() as isize * BYTES_PER_WORD as isize); - Ok((ptr, tag, double_far_segment_id)) + Err(Error::failed(format!("found far pointer but there is not arena"))) } } else { - Ok(((*reff).target_from_segment(arena, segment_id)?, reff, segment_id)) + Ok(((*reff).target_from_segment(arena_and_segment)?, reff, arena_and_segment)) } } - pub unsafe fn zero_object( - arena: &dyn BuilderArena, + pub unsafe fn zero_object( + arena: &mut A, segment_id: u32, reff: *mut WirePointer) + where A: BuilderArena { //# Zero out the pointed-to object. Use when the pointer is //# about to be overwritten making the target object no longer @@ -544,11 +574,12 @@ mod wire_helpers { } } - pub unsafe fn zero_object_helper( - arena: &dyn BuilderArena, + pub unsafe fn zero_object_helper( + arena: &mut A, segment_id: u32, tag: *mut WirePointer, ptr: *mut u8) + where A: BuilderArena { match (*tag).kind() { WirePointerKind::Other => { panic!("Don't know how to handle OTHER") } @@ -611,10 +642,11 @@ mod wire_helpers { } #[inline] - pub unsafe fn zero_pointer_and_fars( - arena: &dyn BuilderArena, + pub unsafe fn zero_pointer_and_fars( + arena: &mut A, _segment_id: u32, reff: *mut WirePointer) -> Result<()> + where A: BuilderArena { // Zero out the pointer itself and, if it is a far pointer, zero the landing pad as well, // but do not zero the object body. Used when upgrading. @@ -630,11 +662,11 @@ mod wire_helpers { Ok(()) } - pub unsafe fn total_size( - arena: &dyn ReaderArena, - segment_id: u32, + pub unsafe fn total_size( + arena_and_segment: Option>, reff: *const WirePointer, mut nesting_limit: i32) -> Result + where A: ReaderArena { let mut result = MessageSize { word_count: 0, cap_count: 0}; @@ -646,11 +678,11 @@ mod wire_helpers { nesting_limit -= 1; - let (ptr, reff, segment_id) = follow_fars(arena, reff, segment_id)?; + let (ptr, reff, arena_and_segment) = follow_fars(arena_and_segment, reff)?; match (*reff).kind() { WirePointerKind::Struct => { - bounds_check(arena, segment_id, + bounds_check(arena_and_segment, ptr, (*reff).struct_word_size() as usize, WirePointerKind::Struct)?; result.word_count += (*reff).struct_word_size() as u64; @@ -659,7 +691,7 @@ mod wire_helpers { ptr.offset((*reff).struct_data_size() as isize * BYTES_PER_WORD as isize) as *const _; let count: isize = (*reff).struct_ptr_count() as isize; for i in 0..count { - result.plus_eq(total_size(arena, segment_id, pointer_section.offset(i), nesting_limit)?); + result.plus_eq(total_size(arena_and_segment, pointer_section.offset(i), nesting_limit)?); } } WirePointerKind::List => { @@ -670,27 +702,27 @@ mod wire_helpers { (*reff).list_element_count() as u64 * data_bits_per_element((*reff).list_element_size()) as u64); bounds_check( - arena, segment_id, ptr, total_words as usize, WirePointerKind::List)?; + arena_and_segment, ptr, total_words as usize, WirePointerKind::List)?; result.word_count += total_words as u64; } Pointer => { let count = (*reff).list_element_count(); bounds_check( - arena, segment_id, ptr, count as usize * WORDS_PER_POINTER, + arena_and_segment, ptr, count as usize * WORDS_PER_POINTER, WirePointerKind::List)?; result.word_count += count as u64 * WORDS_PER_POINTER as u64; for i in 0..count as isize { result.plus_eq( - total_size(arena, segment_id, + total_size(arena_and_segment, (ptr as *const WirePointer).offset(i), nesting_limit)?); } } InlineComposite => { let word_count = (*reff).list_inline_composite_word_count(); - bounds_check(arena, segment_id, ptr, + bounds_check(arena_and_segment, ptr, word_count as usize + POINTER_SIZE_IN_WORDS, WirePointerKind::List)?; @@ -722,7 +754,7 @@ mod wire_helpers { for _ in 0..pointer_count { result.plus_eq( - total_size(arena, segment_id, + total_size(arena_and_segment, pos as *const WirePointer, nesting_limit)?); pos = pos.offset(BYTES_PER_WORD as isize); } @@ -747,14 +779,16 @@ mod wire_helpers { } // Helper for copy_message(). - unsafe fn copy_struct( - arena: &dyn BuilderArena, + unsafe fn copy_struct( + arena: &mut A, segment_id: u32, cap_table: CapTableBuilder, dst: *mut u8, src: *const u8, data_size: isize, - pointer_count: isize) { + pointer_count: isize) + where A: BuilderArena + { ptr::copy_nonoverlapping(src, dst, data_size as usize * BYTES_PER_WORD); let src_refs: *const WirePointer = (src as *const WirePointer).offset(data_size); @@ -767,12 +801,13 @@ mod wire_helpers { // Copies from a trusted message. // Returns (new_dst_ptr, new_dst, new_segment_id). - pub unsafe fn copy_message( - arena: &dyn BuilderArena, + pub unsafe fn copy_message( + arena: &mut A, segment_id: u32, cap_table: CapTableBuilder, dst: *mut WirePointer, src: *const WirePointer) -> (*mut u8, *mut WirePointer, u32) + where A: BuilderArena { match (*src).kind() { WirePointerKind::Struct => { @@ -874,10 +909,11 @@ mod wire_helpers { } } - pub unsafe fn transfer_pointer( - arena: &dyn BuilderArena, + pub unsafe fn transfer_pointer( + arena: &mut A, dst_segment_id: u32, dst: *mut WirePointer, src_segment_id: u32, src: *mut WirePointer) + where A: BuilderArena { //# Make *dst point to the same object as *src. Both must //# reside in the same message, but can be in different @@ -901,11 +937,12 @@ mod wire_helpers { } } - pub unsafe fn transfer_pointer_split( - arena: &dyn BuilderArena, + pub unsafe fn transfer_pointer_split( + arena: &mut A, dst_segment_id: u32, dst: *mut WirePointer, src_segment_id: u32, src_tag: *mut WirePointer, src_ptr: *mut u8) + where A: BuilderArena { // Like the other transfer_pointer, but splits src into a tag and a // target. Particularly useful for OrphanBuilder. @@ -966,12 +1003,13 @@ mod wire_helpers { } #[inline] - pub unsafe fn init_struct_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn init_struct_pointer<'a, A>( + arena: &'a mut A, reff: *mut WirePointer, segment_id: u32, cap_table: CapTableBuilder, - size: StructSize) -> StructBuilder<'a> + size: StructSize) -> StructBuilder<&'a mut A> + where A: BuilderArena { let (ptr, reff, segment_id) = allocate( arena, @@ -993,13 +1031,14 @@ mod wire_helpers { } #[inline] - pub unsafe fn get_writable_struct_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn get_writable_struct_pointer<'a, A>( + arena: &'a mut A, mut reff: *mut WirePointer, mut segment_id: u32, cap_table: CapTableBuilder, size: StructSize, - default: Option<&'a [crate::Word]>) -> Result> + default: Option<&'a [crate::Word]>) -> Result> + where A: BuilderArena { let mut ref_target = (*reff).mut_target(); @@ -1081,13 +1120,14 @@ mod wire_helpers { } #[inline] - pub unsafe fn init_list_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn init_list_pointer<'a, A>( + arena: &'a mut A, reff: *mut WirePointer, segment_id: u32, cap_table: CapTableBuilder, element_count: ElementCount32, - element_size: ElementSize) -> ListBuilder<'a> + element_size: ElementSize) -> ListBuilder<&'a mut A> + where A: BuilderArena { assert!(element_size != InlineComposite, "Should have called initStructListPointer() instead"); @@ -1114,13 +1154,14 @@ mod wire_helpers { } #[inline] - pub unsafe fn init_struct_list_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn init_struct_list_pointer<'a, A>( + arena: &'a mut A, reff: *mut WirePointer, segment_id: u32, cap_table: CapTableBuilder, element_count: ElementCount32, - element_size: StructSize) -> ListBuilder<'a> + element_size: StructSize) -> ListBuilder<&'a mut A> + where A: BuilderArena { let words_per_element = element_size.total(); @@ -1154,13 +1195,14 @@ mod wire_helpers { } #[inline] - pub unsafe fn get_writable_list_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn get_writable_list_pointer<'a, A>( + arena: &'a mut A, mut orig_ref: *mut WirePointer, mut orig_segment_id: u32, cap_table: CapTableBuilder, element_size: ElementSize, - default_value: *const u8) -> Result> + default_value: *const u8) -> Result> + where A: BuilderArena { assert!(element_size != InlineComposite, "Use get_writable_struct_list_pointer() for struct lists"); @@ -1169,7 +1211,17 @@ mod wire_helpers { if (*orig_ref).is_null() { if default_value.is_null() || (*(default_value as *const WirePointer)).is_null() { - return Ok(ListBuilder::new_default()); + return Ok(ListBuilder { + arena, + segment_id: orig_segment_id, + cap_table, + ptr: ptr::null_mut(), + element_count: 0, + element_size: ElementSize::Void, + step: 0, + struct_data_size: 0, + struct_pointer_count: 0, + }) } let (new_orig_ref_target, new_orig_ref, new_orig_segment_id) = copy_message( arena, orig_segment_id, cap_table, orig_ref, default_value as *const WirePointer); @@ -1277,19 +1329,30 @@ mod wire_helpers { } #[inline] - pub unsafe fn get_writable_struct_list_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn get_writable_struct_list_pointer<'a, A>( + arena: &'a mut A, mut orig_ref: *mut WirePointer, mut orig_segment_id: u32, cap_table: CapTableBuilder, element_size: StructSize, - default_value: *const u8) -> Result> + default_value: *const u8) -> Result> + where A: BuilderArena { let mut orig_ref_target = (*orig_ref).mut_target(); if (*orig_ref).is_null() { if default_value.is_null() || (*(default_value as *const WirePointer)).is_null() { - return Ok(ListBuilder::new_default()); + return Ok(ListBuilder { + arena, + segment_id: orig_segment_id, + cap_table, + ptr: ptr::null_mut(), + element_count: 0, + element_size: ElementSize::Void, + step: 0, + struct_data_size: 0, + struct_pointer_count: 0, + }) } let (new_orig_ref_target, new_orig_ref, new_orig_segment_id) = copy_message( arena, orig_segment_id, cap_table, orig_ref, default_value as *const WirePointer); @@ -1480,11 +1543,12 @@ mod wire_helpers { } #[inline] - pub unsafe fn init_text_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn init_text_pointer<'a, A>( + arena: &'a mut A, reff: *mut WirePointer, segment_id: u32, size: ByteCount32) -> SegmentAnd> + where A: BuilderArena { //# The byte list must include a NUL terminator. let byte_size = size + 1; @@ -1504,11 +1568,12 @@ mod wire_helpers { } #[inline] - pub unsafe fn set_text_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn set_text_pointer<'a, A>( + arena: &'a mut A, reff: *mut WirePointer, segment_id: u32, value: &str) -> SegmentAnd> + where A: BuilderArena { let value_bytes = value.as_bytes(); // TODO make sure the string is not longer than 2 ** 29. @@ -1518,11 +1583,12 @@ mod wire_helpers { } #[inline] - pub unsafe fn get_writable_text_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn get_writable_text_pointer<'a, A>( + arena: &'a mut A, mut reff: *mut WirePointer, mut segment_id: u32, default: Option<&'a [crate::Word]>) -> Result> + where A: BuilderArena { let ref_target = if (*reff).is_null() { match default { @@ -1561,11 +1627,12 @@ mod wire_helpers { } #[inline] - pub unsafe fn init_data_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn init_data_pointer<'a, A>( + arena: &'a mut A, reff: *mut WirePointer, segment_id: u32, size: ByteCount32) -> SegmentAnd> + where A: BuilderArena { //# Allocate the space. let (ptr, reff, segment_id) = @@ -1578,11 +1645,12 @@ mod wire_helpers { } #[inline] - pub unsafe fn set_data_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn set_data_pointer<'a, A>( + arena: &'a mut A, reff: *mut WirePointer, segment_id: u32, value: &[u8]) -> SegmentAnd> + where A: BuilderArena { let allocation = init_data_pointer(arena, reff, segment_id, value.len() as u32); ptr::copy_nonoverlapping(value.as_ptr(), allocation.value.as_mut_ptr(), @@ -1591,11 +1659,12 @@ mod wire_helpers { } #[inline] - pub unsafe fn get_writable_data_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn get_writable_data_pointer<'a, A>( + arena: &'a mut A, mut reff: *mut WirePointer, mut segment_id: u32, default: Option<&'a [crate::Word]>) -> Result> + where A: BuilderArena { let ref_target = if (*reff).is_null() { match default { @@ -1626,13 +1695,15 @@ mod wire_helpers { Ok(data::builder_from_raw_parts(ptr, (*reff).list_element_count())) } - pub unsafe fn set_struct_pointer( - arena: &dyn BuilderArena, + pub unsafe fn set_struct_pointer<'a,'b,A,B>( + arena: &'a mut A, segment_id: u32, cap_table: CapTableBuilder, reff: *mut WirePointer, - value: StructReader, + value: StructReader<&'b B>, canonicalize: bool) -> Result> + where A: BuilderArena, + B: ReaderArena { let mut data_size: ByteCount32 = round_bits_up_to_bytes(value.data_size as u64); let mut ptr_count = value.pointer_count; @@ -1688,8 +1759,8 @@ mod wire_helpers { let pointer_section: *mut WirePointer = ptr.offset(data_words as isize * BYTES_PER_WORD as isize) as *mut _; for i in 0..ptr_count as isize { copy_pointer(arena, segment_id, cap_table, pointer_section.offset(i), - value.arena, - value.segment_id, value.cap_table, value.pointers.offset(i), + value.arena_and_segment, + value.cap_table, value.pointers.offset(i), value.nesting_limit, canonicalize)?; } @@ -1697,24 +1768,27 @@ mod wire_helpers { Ok(SegmentAnd { segment_id: segment_id, value: ptr }) } - pub fn set_capability_pointer( - _arena: &dyn BuilderArena, + pub fn set_capability_pointer( + _arena: &mut A, _segment_id: u32, mut cap_table: CapTableBuilder, reff: *mut WirePointer, cap: Box) + where A: BuilderArena { // TODO if ref is not null, zero object. unsafe { (*reff).set_cap(cap_table.inject_cap(cap) as u32); } } - pub unsafe fn set_list_pointer<'a>( - arena: &'a dyn BuilderArena, + pub unsafe fn set_list_pointer<'a,'b,A,B>( + arena: &'a mut A, segment_id: u32, cap_table: CapTableBuilder, reff: *mut WirePointer, - value: ListReader, + value: ListReader<&'b B>, canonicalize: bool) -> Result> + where A: BuilderArena, + B: ReaderArena { let total_size = round_bits_up_to_words((value.element_count * value.step) as u64); @@ -1729,8 +1803,8 @@ mod wire_helpers { for i in 0.. value.element_count as isize { copy_pointer(arena, segment_id, cap_table, (ptr as *mut WirePointer).offset(i), - value.arena, - value.segment_id, value.cap_table, + value.arena_and_segment, + value.cap_table, (value.ptr as *const WirePointer).offset(i), value.nesting_limit, canonicalize)?; @@ -1827,7 +1901,7 @@ mod wire_helpers { for _ in 0..ptr_count { copy_pointer(arena, segment_id, cap_table, dst as *mut _, - value.arena, value.segment_id, value.cap_table, src as *const WirePointer, + value.arena_and_segment, value.cap_table, src as *const WirePointer, value.nesting_limit, canonicalize)?; dst = dst.offset(BYTES_PER_WORD as isize); src = src.offset(BYTES_PER_WORD as isize); @@ -1839,22 +1913,24 @@ mod wire_helpers { } } - pub unsafe fn copy_pointer( - dst_arena: &dyn BuilderArena, + pub unsafe fn copy_pointer<'a, 'b, A, B>( + dst_arena: &'a mut A, dst_segment_id: u32, dst_cap_table: CapTableBuilder, dst: *mut WirePointer, - src_arena: &dyn ReaderArena, - src_segment_id: u32, src_cap_table: CapTableReader, + src_arena_and_segment: Option>, + src_cap_table: CapTableReader, src: *const WirePointer, nesting_limit: i32, canonicalize: bool) -> Result> + where A: BuilderArena, + B: ReaderArena { if (*src).is_null() { ptr::write_bytes(dst, 0, 1); return Ok(SegmentAnd { segment_id: dst_segment_id, value: ptr::null_mut() }); } - let (mut ptr, src, src_segment_id) = follow_fars(src_arena, src, src_segment_id)?; + let (mut ptr, src, src_arena_and_segment) = follow_fars(src_arena_and_segment, src)?; match (*src).kind() { WirePointerKind::Struct => { @@ -1863,7 +1939,7 @@ mod wire_helpers { "Message is too deeply-nested or contains cycles. See ReaderOptions.".to_string())); } - bounds_check(src_arena, src_segment_id, + bounds_check(src_arena_and_segment, ptr, (*src).struct_word_size() as usize, WirePointerKind::Struct)?; @@ -1871,8 +1947,7 @@ mod wire_helpers { dst_arena, dst_segment_id, dst_cap_table, dst, StructReader { - arena: src_arena, - segment_id: src_segment_id, + arena_and_segment: src_arena_and_segment, cap_table: src_cap_table, data: ptr, pointers: ptr.offset((*src).struct_data_size() as isize * BYTES_PER_WORD as isize) as *const _, @@ -1895,7 +1970,7 @@ mod wire_helpers { ptr = ptr.offset(BYTES_PER_WORD as isize); bounds_check( - src_arena, src_segment_id, ptr.offset(-(BYTES_PER_WORD as isize)), word_count as usize + 1, + src_arena_and_segment, ptr.offset(-(BYTES_PER_WORD as isize)), word_count as usize + 1, WirePointerKind::List)?; if (*tag).kind() != WirePointerKind::Struct { @@ -1914,15 +1989,14 @@ mod wire_helpers { if words_per_element == 0 { // Watch out for lists of zero-sized structs, which can claim to be // arbitrarily large without having sent actual data. - amplified_read(src_arena, element_count as u64)?; + amplified_read(src_arena_and_segment, element_count as u64)?; } set_list_pointer( dst_arena, dst_segment_id, dst_cap_table, dst, ListReader { - arena: src_arena, - segment_id: src_segment_id, + arena_and_segment: src_arena_and_segment, cap_table: src_cap_table, ptr: ptr as *const _, element_count: element_count, @@ -1940,22 +2014,21 @@ mod wire_helpers { let element_count = (*src).list_element_count(); let word_count = round_bits_up_to_words(element_count as u64 * step as u64); - bounds_check(src_arena, - src_segment_id, ptr, + bounds_check(src_arena_and_segment, + ptr, word_count as usize, WirePointerKind::List)?; if element_size == Void { // Watch out for lists of void, which can claim to be arbitrarily large // without having sent actual data. - amplified_read(src_arena, element_count as u64)?; + amplified_read(src_arena_and_segment, element_count as u64)?; } set_list_pointer( dst_arena, dst_segment_id, dst_cap_table, dst, ListReader { - arena: src_arena, - segment_id: src_segment_id, + arena_and_segment: src_arena_and_segment, cap_table : src_cap_table, ptr: ptr as *const _, element_count: element_count, @@ -1993,13 +2066,13 @@ mod wire_helpers { } #[inline] - pub unsafe fn read_struct_pointer<'a>( - mut arena: &'a dyn ReaderArena, - mut segment_id: u32, + pub unsafe fn read_struct_pointer<'a, A>( + mut arena_and_segment: Option>, cap_table: CapTableReader, mut reff: *const WirePointer, default: Option<&'a [crate::Word]>, - nesting_limit: i32) -> Result> + nesting_limit: i32) -> Result> + where A: ReaderArena { if (*reff).is_null() { match default { @@ -2008,8 +2081,7 @@ mod wire_helpers { return Ok(StructReader::new_default()), Some(d) => { reff = d.as_ptr() as *const _; - arena = &super::NULL_ARENA; - segment_id = 0; + arena_and_segment = None; } } } @@ -2018,7 +2090,7 @@ mod wire_helpers { return Err(Error::failed("Message is too deeply-nested or contains cycles.".to_string())); } - let (ptr, reff, segment_id) = follow_fars(arena, reff, segment_id)?; + let (ptr, reff, arena_and_segment) = follow_fars(arena_and_segment, reff)?; let data_size_words = (*reff).struct_data_size(); @@ -2027,13 +2099,12 @@ mod wire_helpers { "Message contains non-struct pointer where struct pointer was expected.".to_string())); } - bounds_check(arena, segment_id, ptr, + bounds_check(arena_and_segment, ptr, (*reff).struct_word_size() as usize, WirePointerKind::Struct)?; Ok(StructReader { - arena: arena, - segment_id: segment_id, + arena_and_segment: arena_and_segment, cap_table: cap_table, data: ptr, pointers: ptr.offset(data_size_words as isize * BYTES_PER_WORD as isize) as *const _, @@ -2044,12 +2115,12 @@ mod wire_helpers { } #[inline] - pub unsafe fn read_capability_pointer( - _arena: &dyn ReaderArena, - _segment_id: u32, + pub unsafe fn read_capability_pointer( + _arena_and_segment: Option>, cap_table: CapTableReader, reff: *const WirePointer, _nesting_limit: i32) -> Result> + where A: ReaderArena { if (*reff).is_null() { Err(Error::failed( @@ -2070,28 +2141,27 @@ mod wire_helpers { } #[inline] - pub unsafe fn read_list_pointer<'a>( - mut arena: &'a dyn ReaderArena, - mut segment_id: u32, + pub unsafe fn read_list_pointer<'a, A>( + mut arena_and_segment: Option>, cap_table: CapTableReader, mut reff: *const WirePointer, default_value: *const u8, expected_element_size: Option, - nesting_limit: i32) -> Result> + nesting_limit: i32) -> Result> + where A: ReaderArena { if (*reff).is_null() { if default_value.is_null() || (*(default_value as *const WirePointer)).is_null() { return Ok(ListReader::new_default()); } reff = default_value as *const _; - arena = &super::NULL_ARENA; - segment_id = 0; + arena_and_segment = None; } if nesting_limit <= 0 { return Err(Error::failed("nesting limit exceeded".to_string())); } - let (mut ptr, reff, segment_id) = follow_fars(arena, reff, segment_id)?; + let (mut ptr, reff, arena_and_segment) = follow_fars(arena_and_segment, reff)?; if (*reff).kind() != WirePointerKind::List { return Err(Error::failed( @@ -2107,7 +2177,7 @@ mod wire_helpers { ptr = ptr.offset(BYTES_PER_WORD as isize); - bounds_check(arena, segment_id, ptr.offset(-(BYTES_PER_WORD as isize)), + bounds_check(arena_and_segment, ptr.offset(-(BYTES_PER_WORD as isize)), word_count as usize + 1, WirePointerKind::List)?; @@ -2129,7 +2199,7 @@ mod wire_helpers { if words_per_element == 0 { // Watch out for lists of zero-sized structs, which can claim to be // arbitrarily large without having sent actual data. - amplified_read(arena, size as u64)?; + amplified_read(arena_and_segment, size as u64)?; } // If a struct list was not expected, then presumably a non-struct list was upgraded @@ -2163,8 +2233,7 @@ mod wire_helpers { } Ok(ListReader { - arena: arena, - segment_id: segment_id, + arena_and_segment: arena_and_segment, cap_table: cap_table, ptr: ptr as *const _, element_count: size, @@ -2186,12 +2255,12 @@ mod wire_helpers { let word_count = round_bits_up_to_words(element_count as u64 * step as u64); bounds_check( - arena, segment_id, ptr, word_count as usize, WirePointerKind::List)?; + arena_and_segment, ptr, word_count as usize, WirePointerKind::List)?; if element_size == Void { // Watch out for lists of void, which can claim to be arbitrarily large // without having sent actual data. - amplified_read(arena, element_count as u64)?; + amplified_read(arena_and_segment, element_count as u64)?; } if let Some(expected_element_size) = expected_element_size { @@ -2217,8 +2286,7 @@ mod wire_helpers { } Ok(ListReader { - arena: arena, - segment_id: segment_id, + arena_and_segment: arena_and_segment, cap_table: cap_table, ptr: ptr as *const _, element_count: element_count, @@ -2233,24 +2301,23 @@ mod wire_helpers { } #[inline] - pub unsafe fn read_text_pointer<'a>( - mut arena: &'a dyn ReaderArena, - mut segment_id: u32, + pub unsafe fn read_text_pointer<'a, A>( + mut arena_and_segment: Option>, mut reff: *const WirePointer, default: Option<&[crate::Word]>) -> Result> + where A: ReaderArena { if (*reff).is_null() { match default { None => return Ok(&""), Some(d) => { reff = d.as_ptr() as *const WirePointer; - arena = &super::NULL_ARENA; - segment_id = 0; + arena_and_segment = None; } } } - let (ptr, reff, segment_id) = follow_fars(arena, reff, segment_id)?; + let (ptr, reff, arena_and_segment) = follow_fars(arena_and_segment, reff)?; let size = (*reff).list_element_count(); if (*reff).kind() != WirePointerKind::List { @@ -2263,7 +2330,7 @@ mod wire_helpers { "Message contains list pointer of non-bytes where text was expected.".to_string())); } - bounds_check(arena, segment_id, ptr, + bounds_check(arena_and_segment, ptr, round_bytes_up_to_words(size) as usize, WirePointerKind::List)?; @@ -2282,24 +2349,23 @@ mod wire_helpers { } #[inline] - pub unsafe fn read_data_pointer<'a>( - mut arena: &'a dyn ReaderArena, - mut segment_id: u32, + pub unsafe fn read_data_pointer<'a, A>( + mut arena_and_segment: Option>, mut reff: *const WirePointer, default: Option<&'a [crate::Word]>) -> Result> + where A: ReaderArena { if (*reff).is_null() { match default { None => return Ok(&[]), Some(d) => { reff = d.as_ptr() as *const WirePointer; - arena = &super::NULL_ARENA; - segment_id = 0; + arena_and_segment = None; } } } - let (ptr, reff, segment_id) = follow_fars(arena, reff, segment_id)?; + let (ptr, reff, arena_and_segment) = follow_fars(arena_and_segment, reff)?; let size: u32 = (*reff).list_element_count(); @@ -2313,7 +2379,7 @@ mod wire_helpers { "Message contains list pointer of non-bytes where data was expected.".to_string())); } - bounds_check(arena, segment_id, ptr, + bounds_check(arena_and_segment, ptr, round_bytes_up_to_words(size) as usize, WirePointerKind::List)?; @@ -2324,8 +2390,6 @@ mod wire_helpers { static ZERO: u64 = 0; fn zero_pointer() -> *const WirePointer { &ZERO as *const _ as *const _ } -static NULL_ARENA: NullArena = NullArena; - pub type CapTable = Vec>>; #[derive(Copy, Clone)] @@ -2417,53 +2481,52 @@ impl CapTableBuilder { #[derive(Clone, Copy)] -pub struct PointerReader<'a> { - arena: &'a dyn ReaderArena, +pub struct PointerReader { + arena_and_segment: Option>, cap_table: CapTableReader, pointer: *const WirePointer, - segment_id: u32, nesting_limit: i32, } -impl <'a> PointerReader<'a> { - pub fn new_default<'b>() -> PointerReader<'b> { +impl PointerReader<&'static NullArena> { + pub fn get_root_unchecked(location: *const u8) -> PointerReader<&'static NullArena> { PointerReader { - arena: &NULL_ARENA, - segment_id: 0, + arena_and_segment: None, + cap_table: CapTableReader::Plain(ptr::null()), + pointer: location as *const _, + nesting_limit: 0x7fffffff } + } +} + +impl <'a, A> PointerReader<&'a A> where A: ReaderArena { + pub fn new_default() -> PointerReader<&'a A> { + PointerReader { + arena_and_segment: None, cap_table: CapTableReader::Plain(ptr::null()), pointer: ptr::null(), nesting_limit: 0x7fffffff } } - pub fn get_root(arena: &'a dyn ReaderArena, + pub fn get_root(arena: &'a A, segment_id: u32, location: *const u8, nesting_limit: i32) -> Result { - wire_helpers::bounds_check(arena, segment_id, location as *const _, + let arena_and_segment = Some(ArenaAndSegment { arena, segment_id }); + wire_helpers::bounds_check(arena_and_segment, location as *const _, POINTER_SIZE_IN_WORDS, WirePointerKind::Struct)?; Ok(PointerReader { - arena: arena, - segment_id: segment_id, + arena_and_segment, cap_table: CapTableReader::Plain(ptr::null()), pointer: location as *const _, nesting_limit: nesting_limit, }) } - pub fn borrow<'b>(&'b self) -> PointerReader<'b> { - PointerReader { arena: self.arena, .. *self } - } - - pub fn get_root_unchecked<'b>(location: *const u8) -> PointerReader<'b> { - PointerReader { - arena: &NULL_ARENA, - segment_id: 0, - cap_table: CapTableReader::Plain(ptr::null()), - pointer: location as *const _, - nesting_limit: 0x7fffffff } + pub fn borrow<'b>(&'b self) -> PointerReader<&'b A> { + PointerReader { arena_and_segment: self.arena_and_segment, .. *self } } pub fn imbue(&mut self, cap_table: CapTableReader) { @@ -2478,27 +2541,26 @@ impl <'a> PointerReader<'a> { if self.pointer.is_null() { Ok( MessageSize { word_count: 0, cap_count: 0 } ) } else { - unsafe { wire_helpers::total_size(self.arena, self.segment_id, self.pointer, self.nesting_limit) } + unsafe { wire_helpers::total_size(self.arena_and_segment, self.pointer, self.nesting_limit) } } } - pub fn get_struct(self, default: Option<&'a [crate::Word]>) -> Result> { + pub fn get_struct(self, default: Option<&'a [crate::Word]>) -> Result> { let reff: *const WirePointer = if self.pointer.is_null() { zero_pointer() } else { self.pointer }; unsafe { - wire_helpers::read_struct_pointer(self.arena, - self.segment_id, self.cap_table, reff, + wire_helpers::read_struct_pointer(self.arena_and_segment, + self.cap_table, reff, default, self.nesting_limit) } } pub fn get_list(self, expected_element_size: ElementSize, - default: Option<&'a [crate::Word]>) -> Result> { + default: Option<&'a [crate::Word]>) -> Result> { let default_value: *const u8 = match default { None => core::ptr::null(), Some(d) => d.as_ptr() as *const u8}; let reff = if self.pointer.is_null() { zero_pointer() } else { self.pointer }; unsafe { wire_helpers::read_list_pointer( - self.arena, - self.segment_id, + self.arena_and_segment, self.cap_table, reff, default_value, @@ -2506,12 +2568,11 @@ impl <'a> PointerReader<'a> { } } - fn get_list_any_size(self, default_value: *const u8) -> Result> { + fn get_list_any_size(self, default_value: *const u8) -> Result> { let reff = if self.pointer.is_null() { zero_pointer() } else { self.pointer }; unsafe { wire_helpers::read_list_pointer( - self.arena, - self.segment_id, + self.arena_and_segment, self.cap_table, reff, default_value, @@ -2522,14 +2583,14 @@ impl <'a> PointerReader<'a> { pub fn get_text(self, default: Option<&[crate::Word]>) -> Result> { let reff = if self.pointer.is_null() { zero_pointer() } else { self.pointer }; unsafe { - wire_helpers::read_text_pointer(self.arena, self.segment_id, reff, default) + wire_helpers::read_text_pointer(self.arena_and_segment, reff, default) } } pub fn get_data(&self, default: Option<&'a [crate::Word]>) -> Result> { let reff = if self.pointer.is_null() { zero_pointer() } else { self.pointer }; unsafe { - wire_helpers::read_data_pointer(self.arena, self.segment_id, reff, default) + wire_helpers::read_data_pointer(self.arena_and_segment, reff, default) } } @@ -2537,7 +2598,7 @@ impl <'a> PointerReader<'a> { let reff: *const WirePointer = if self.pointer.is_null() { zero_pointer() } else { self.pointer }; unsafe { wire_helpers::read_capability_pointer( - self.arena, self.segment_id, self.cap_table, reff, self.nesting_limit) + self.arena_and_segment, self.cap_table, reff, self.nesting_limit) } } @@ -2546,7 +2607,7 @@ impl <'a> PointerReader<'a> { Ok(PointerType::Null) } else { let (_, reff, _) = unsafe { - wire_helpers::follow_fars(self.arena, self.pointer, self.segment_id)? + wire_helpers::follow_fars(self.arena_and_segment, self.pointer)? }; match unsafe { (*reff).kind() } { @@ -2592,17 +2653,17 @@ impl <'a> PointerReader<'a> { } #[derive(Clone, Copy)] -pub struct PointerBuilder<'a> { - arena: &'a dyn BuilderArena, +pub struct PointerBuilder { + arena: A, segment_id: u32, cap_table: CapTableBuilder, pointer: *mut WirePointer } -impl <'a> PointerBuilder<'a> { +impl <'a, A> PointerBuilder<&'a mut A> where A: BuilderArena { #[inline] pub fn get_root( - arena: &'a dyn BuilderArena, + arena: &'a mut A, segment_id: u32, location: *mut u8) -> Self @@ -2615,10 +2676,19 @@ impl <'a> PointerBuilder<'a> { } } - pub fn borrow<'b>(&'b mut self) -> PointerBuilder<'b> { + pub fn borrow<'b>(&'b mut self) -> PointerBuilder<&'b mut A> { PointerBuilder { arena: self.arena, .. *self } } + pub fn reborrow_as_reader<'b>(&'b self) -> PointerReader<&'b A> { + PointerReader { + arena_and_segment: Some(ArenaAndSegment { arena: self.arena, segment_id: self.segment_id }), + cap_table: self.cap_table.into_reader(), + pointer: self.pointer, + nesting_limit: 0x7fffffff + } + } + pub fn imbue(&mut self, cap_table: CapTableBuilder) { self.cap_table = cap_table; } @@ -2627,7 +2697,7 @@ impl <'a> PointerBuilder<'a> { unsafe { (*self.pointer).is_null() } } - pub fn get_struct(self, size: StructSize, default: Option<&'a [crate::Word]>) -> Result> { + pub fn get_struct(self, size: StructSize, default: Option<&'a [crate::Word]>) -> Result> { unsafe { wire_helpers::get_writable_struct_pointer( self.arena, @@ -2640,7 +2710,7 @@ impl <'a> PointerBuilder<'a> { } pub fn get_list(self, element_size: ElementSize, default: Option<&'a [crate::Word]>) - -> Result> + -> Result> { let default_value: *const u8 = match default { None => core::ptr::null(), Some(d) => d.as_ptr() as *const u8}; unsafe { @@ -2650,7 +2720,7 @@ impl <'a> PointerBuilder<'a> { } pub fn get_struct_list(self, element_size: StructSize, - default: Option<&'a [crate::Word]>) -> Result> + default: Option<&'a [crate::Word]>) -> Result> { let default_value: *const u8 = match default { None => core::ptr::null(), Some(d) => d.as_ptr() as *const u8}; unsafe { @@ -2680,18 +2750,18 @@ impl <'a> PointerBuilder<'a> { pub fn get_capability(&self) -> Result> { unsafe { wire_helpers::read_capability_pointer( - self.arena.as_reader(), - self.segment_id, self.cap_table.into_reader(), self.pointer, ::core::i32::MAX) + Some(ArenaAndSegment { arena: &*self.arena, segment_id: self.segment_id }), + self.cap_table.into_reader(), self.pointer, ::core::i32::MAX) } } - pub fn init_struct(self, size: StructSize) -> StructBuilder<'a> { + pub fn init_struct(self, size: StructSize) -> StructBuilder<&'a mut A> { unsafe { wire_helpers::init_struct_pointer(self.arena, self.pointer, self.segment_id, self.cap_table, size) } } - pub fn init_list(self, element_size: ElementSize, element_count: ElementCount32) -> ListBuilder<'a> { + pub fn init_list(self, element_size: ElementSize, element_count: ElementCount32) -> ListBuilder<&'a mut A> { unsafe { wire_helpers::init_list_pointer( self.arena, self.pointer, self.segment_id, self.cap_table, element_count, element_size) @@ -2699,7 +2769,7 @@ impl <'a> PointerBuilder<'a> { } pub fn init_struct_list(self, element_count: ElementCount32, element_size: StructSize) - -> ListBuilder<'a> { + -> ListBuilder<&'a mut A> { unsafe { wire_helpers::init_struct_list_pointer( self.arena, @@ -2720,7 +2790,9 @@ impl <'a> PointerBuilder<'a> { } } - pub fn set_struct(&self, value: &StructReader, canonicalize: bool) -> Result<()> { + pub fn set_struct(self, value: &StructReader<&B>, canonicalize: bool) -> Result<()> + where B: ReaderArena + { unsafe { wire_helpers::set_struct_pointer( self.arena, @@ -2729,7 +2801,9 @@ impl <'a> PointerBuilder<'a> { } } - pub fn set_list(&self, value: &ListReader, canonicalize: bool) -> Result<()> { + pub fn set_list(self, value: &ListReader<&B>, canonicalize: bool) -> Result<()> + where B: ReaderArena + { unsafe { wire_helpers::set_list_pointer(self.arena, self.segment_id, self.cap_table, self.pointer, *value, canonicalize)?; @@ -2737,24 +2811,26 @@ impl <'a> PointerBuilder<'a> { } } - pub fn set_text(&self, value: &str) { + pub fn set_text(self, value: &str) { unsafe { wire_helpers::set_text_pointer(self.arena, self.pointer, self.segment_id, value); } } - pub fn set_data(&self, value: &[u8]) { + pub fn set_data(self, value: &[u8]) { unsafe { wire_helpers::set_data_pointer(self.arena, self.pointer, self.segment_id, value); } } - pub fn set_capability(&self, cap: Box) { + pub fn set_capability(&mut self, cap: Box) { wire_helpers::set_capability_pointer( self.arena, self.segment_id, self.cap_table, self.pointer, cap); } - pub fn copy_from(&mut self, other: PointerReader, canonicalize: bool) -> Result<()> { + pub fn copy_from(&mut self, other: PointerReader<&B>, canonicalize: bool) -> Result<()> + where B: ReaderArena + { if other.pointer.is_null() { if !self.pointer.is_null() { unsafe { @@ -2765,8 +2841,8 @@ impl <'a> PointerBuilder<'a> { } else { unsafe { wire_helpers::copy_pointer(self.arena, self.segment_id, self.cap_table, self.pointer, - other.arena, - other.segment_id, other.cap_table, other.pointer, + other.arena_and_segment, + other.cap_table, other.pointer, other.nesting_limit, canonicalize)?; } } @@ -2780,10 +2856,9 @@ impl <'a> PointerBuilder<'a> { } } - pub fn into_reader(self) -> PointerReader<'a> { + pub fn into_reader(self) -> PointerReader<&'a A> { PointerReader { - arena: self.arena.as_reader(), - segment_id: self.segment_id, + arena_and_segment: Some(ArenaAndSegment { arena: self.arena, segment_id: self.segment_id }), cap_table: self.cap_table.into_reader(), pointer: self.pointer, nesting_limit: 0x7fffffff @@ -2792,22 +2867,20 @@ impl <'a> PointerBuilder<'a> { } #[derive(Clone, Copy)] -pub struct StructReader<'a> { - arena: &'a dyn ReaderArena, +pub struct StructReader { + arena_and_segment: Option>, cap_table: CapTableReader, data: *const u8, pointers: *const WirePointer, - segment_id: u32, data_size: BitCount32, pointer_count: WirePointerCount16, nesting_limit: i32, } -impl <'a> StructReader<'a> { - pub fn new_default<'b>() -> StructReader<'b> { +impl <'a,A> StructReader<&'a A> where A: ReaderArena { + pub fn new_default() -> StructReader<&'a A> { StructReader { - arena: &NULL_ARENA, - segment_id: 0, + arena_and_segment: None, cap_table: CapTableReader::Plain(ptr::null()), data: ptr::null(), pointers: ptr::null(), @@ -2824,10 +2897,9 @@ impl <'a> StructReader<'a> { pub fn get_pointer_section_size(&self) -> WirePointerCount16 { self.pointer_count } - pub fn get_pointer_section_as_list(&self) -> ListReader<'a> { + pub fn get_pointer_section_as_list(&self) -> ListReader<&'a A> { ListReader { - arena: self.arena, - segment_id: self.segment_id, + arena_and_segment: self.arena_and_segment, cap_table: self.cap_table, ptr: self.pointers as *const _, element_count: self.pointer_count as ElementCount32, @@ -2857,9 +2929,9 @@ impl <'a> StructReader<'a> { // been created with an old version of the protocol that did // not contain the field. if (offset + 1) * bits_per_element::() <= self.data_size as usize { - let dwv: *const ::Raw = self.data as *const _; + let dwv: *const WireValue = self.data as *const _; unsafe { - ::get(&*dwv.offset(offset as isize)) + (*dwv.offset(offset as isize)).get() } } else { T::zero() @@ -2894,11 +2966,10 @@ impl <'a> StructReader<'a> { } #[inline] - pub fn get_pointer_field(&self, ptr_index: WirePointerCount) -> PointerReader<'a> { + pub fn get_pointer_field(&self, ptr_index: WirePointerCount) -> PointerReader<&'a A> { if ptr_index < self.pointer_count as WirePointerCount { PointerReader { - arena: self.arena, - segment_id: self.segment_id, + arena_and_segment: self.arena_and_segment, cap_table: self.cap_table, pointer: unsafe { self.pointers.offset(ptr_index as isize) }, nesting_limit: self.nesting_limit @@ -2917,7 +2988,7 @@ impl <'a> StructReader<'a> { for i in 0.. self.pointer_count as isize { unsafe { result.plus_eq(wire_helpers::total_size( - self.arena, self.segment_id, self.pointers.offset(i), + self.arena_and_segment, self.pointers.offset(i), self.nesting_limit)?); } } @@ -2978,8 +3049,8 @@ impl <'a> StructReader<'a> { } #[derive(Clone, Copy)] -pub struct StructBuilder<'a> { - arena: &'a dyn BuilderArena, +pub struct StructBuilder { + arena: A, cap_table: CapTableBuilder, data: *mut u8, pointers: *mut WirePointer, @@ -2988,15 +3059,14 @@ pub struct StructBuilder<'a> { pointer_count: WirePointerCount16, } -impl <'a> StructBuilder<'a> { - pub fn into_reader(self) -> StructReader<'a> { +impl <'a, A> StructBuilder<&'a mut A> where A: BuilderArena { + pub fn into_reader(self) -> StructReader<&'a A> { StructReader { - arena: self.arena.as_reader(), + arena_and_segment: Some(ArenaAndSegment { arena: &*self.arena, segment_id: self.segment_id }), cap_table: self.cap_table.into_reader(), data: self.data, pointers: self.pointers, pointer_count: self.pointer_count, - segment_id: self.segment_id, data_size: self.data_size, nesting_limit: 0x7fffffff, } @@ -3006,11 +3076,27 @@ impl <'a> StructBuilder<'a> { self.cap_table = cap_table } + pub fn reborrow<'b>(&'b mut self) -> StructBuilder<&'b mut A> { + StructBuilder { arena: self.arena, ..*self } + } + + pub fn reborrow_as_reader<'b>(&'b self) -> StructReader<&'b A> { + StructReader { + arena_and_segment: Some(ArenaAndSegment { arena: self.arena, segment_id: self.segment_id }), + cap_table: self.cap_table.into_reader(), + data: self.data, + pointers: self.pointers, + data_size: self.data_size, + pointer_count: self.pointer_count, + nesting_limit: 0x7fffffff, + } + } + #[inline] pub fn set_data_field(&self, offset: ElementCount, value: T) { - let ptr: *mut ::Raw = self.data as *mut _; + let ptr: *mut WireValue = self.data as *mut _; unsafe { - ::set(&mut*ptr.offset(offset as isize), value) + (*ptr.offset(offset as isize)).set(value) } } @@ -3024,9 +3110,9 @@ impl <'a> StructBuilder<'a> { #[inline] pub fn get_data_field(&self, offset: ElementCount) -> T { - let ptr: *const ::Raw = self.data as *const _; + let ptr: *const WireValue = self.data as *const _; unsafe { - ::get(&*ptr.offset(offset as isize)) + (*ptr.offset(offset as isize)).get() } } @@ -3072,7 +3158,7 @@ impl <'a> StructBuilder<'a> { #[inline] - pub fn get_pointer_field(self, ptr_index: WirePointerCount) -> PointerBuilder<'a> { + pub fn get_pointer_field(self, ptr_index: WirePointerCount) -> PointerBuilder<&'a mut A> { PointerBuilder { arena: self.arena, segment_id: self.segment_id, @@ -3081,7 +3167,7 @@ impl <'a> StructBuilder<'a> { } } - pub fn copy_content_from(&mut self, other: &StructReader) -> Result<()> { + pub fn copy_content_from(&mut self, other: &StructReader<&B>) -> Result<()> where B: ReaderArena { use core::cmp::min; // Determine the amount of data the builders have in common. let shared_data_size = min(self.data_size, other.data_size); @@ -3130,8 +3216,7 @@ impl <'a> StructBuilder<'a> { self.segment_id, self.cap_table, self.pointers.offset(i), - other.arena, - other.segment_id, + other.arena_and_segment, other.cap_table, other.pointers.offset(i), other.nesting_limit, @@ -3144,11 +3229,10 @@ impl <'a> StructBuilder<'a> { } #[derive(Clone, Copy)] -pub struct ListReader<'a> { - arena: &'a dyn ReaderArena, +pub struct ListReader { + arena_and_segment: Option>, cap_table: CapTableReader, ptr: *const u8, - segment_id: u32, element_count: ElementCount32, step: BitCount32, struct_data_size: BitCount32, @@ -3157,11 +3241,10 @@ pub struct ListReader<'a> { element_size: ElementSize, } -impl <'a> ListReader<'a> { - pub fn new_default<'b>() -> ListReader<'b> { +impl <'a, A> ListReader<&'a A> where A: ReaderArena { + pub fn new_default() -> ListReader<&'a A> { ListReader { - arena: &NULL_ARENA, - segment_id: 0, + arena_and_segment: None, cap_table: CapTableReader::Plain(ptr::null()), ptr: ptr::null(), element_count: 0, @@ -3203,7 +3286,7 @@ impl <'a> ListReader<'a> { } #[inline] - pub fn get_struct_element(&self, index: ElementCount32) -> StructReader<'a> { + pub fn get_struct_element(&self, index: ElementCount32) -> StructReader<&'a A> { let index_byte: ByteCount32 = ((index as ElementCount64 * (self.step as BitCount64)) / BITS_PER_BYTE as u64) as u32; @@ -3214,8 +3297,7 @@ impl <'a> ListReader<'a> { }; StructReader { - arena: self.arena, - segment_id: self.segment_id, + arena_and_segment: self.arena_and_segment, cap_table: self.cap_table, data: struct_data, pointers: struct_pointers, @@ -3226,11 +3308,10 @@ impl <'a> ListReader<'a> { } #[inline] - pub fn get_pointer_element(self, index: ElementCount32) -> PointerReader<'a> { + pub fn get_pointer_element(self, index: ElementCount32) -> PointerReader<&'a A> { let offset = (index as u64 * self.step as u64 / BITS_PER_BYTE as u64) as u32; PointerReader { - arena: self.arena, - segment_id: self.segment_id, + arena_and_segment: self.arena_and_segment, cap_table: self.cap_table, pointer: unsafe { self.ptr.offset(offset as isize) } as *const _, nesting_limit: self.nesting_limit @@ -3336,8 +3417,8 @@ impl <'a> ListReader<'a> { } #[derive(Clone, Copy)] -pub struct ListBuilder<'a> { - arena: &'a dyn BuilderArena, +pub struct ListBuilder { + arena: A, cap_table: CapTableBuilder, ptr: *mut u8, segment_id: u32, @@ -3348,27 +3429,10 @@ pub struct ListBuilder<'a> { element_size: ElementSize, } -impl <'a> ListBuilder<'a> { - - #[inline] - pub fn new_default<'b>() -> ListBuilder<'b> { - ListBuilder { - arena: &NULL_ARENA, - segment_id: 0, - cap_table: CapTableBuilder::Plain(ptr::null_mut()), - ptr: ptr::null_mut(), - element_count: 0, - element_size: ElementSize::Void, - step: 0, - struct_data_size: 0, - struct_pointer_count: 0, - } - } - - pub fn into_reader(self) -> ListReader<'a> { +impl <'a, A> ListBuilder<&'a mut A> { + pub fn into_reader(self) -> ListReader<&'a A> { ListReader { - arena: self.arena.as_reader(), - segment_id: self.segment_id, + arena_and_segment: Some(ArenaAndSegment {arena: self.arena, segment_id: self.segment_id}), cap_table: self.cap_table.into_reader(), ptr: self.ptr as *const _, element_count: self.element_count, @@ -3380,7 +3444,7 @@ impl <'a> ListBuilder<'a> { } } - pub fn borrow<'b>(&'b mut self) -> ListBuilder<'b> { + pub fn reborrow<'b>(&'b mut self) -> ListBuilder<&'b mut A> { ListBuilder { arena: self.arena, ..*self } } @@ -3392,7 +3456,7 @@ impl <'a> ListBuilder<'a> { pub fn len(&self) -> ElementCount32 { self.element_count } #[inline] - pub fn get_struct_element(self, index: ElementCount32) -> StructBuilder<'a> { + pub fn get_struct_element(self, index: ElementCount32) -> StructBuilder<&'a mut A> { let index_byte = ((index as u64 * self.step as u64) / BITS_PER_BYTE as u64) as u32; let struct_data = unsafe{ self.ptr.offset(index_byte as isize)}; let struct_pointers = unsafe { @@ -3410,7 +3474,7 @@ impl <'a> ListBuilder<'a> { } #[inline] - pub fn get_pointer_element(self, index: ElementCount32) -> PointerBuilder<'a> { + pub fn get_pointer_element(self, index: ElementCount32) -> PointerBuilder<&'a mut A> { let offset = (index as u64 * self.step as u64 / BITS_PER_BYTE as u64) as u32; PointerBuilder { arena: self.arena, @@ -3423,37 +3487,37 @@ impl <'a> ListBuilder<'a> { pub trait PrimitiveElement { - fn get(list_reader: &ListReader, index: ElementCount32) -> Self; - fn get_from_builder(list_builder: &ListBuilder, index: ElementCount32) -> Self; - fn set(list_builder: &ListBuilder, index: ElementCount32, value: Self); + fn get(list_reader: &ListReader<&A>, index: ElementCount32) -> Self where A: ReaderArena; + fn get_from_builder(list_builder: &ListBuilder<&mut A>, index: ElementCount32) -> Self where A: BuilderArena; + fn set(list_builder: &ListBuilder<&mut A>, index: ElementCount32, value: Self) where A: BuilderArena; fn element_size() -> ElementSize; } -impl PrimitiveElement for T { +impl PrimitiveElement for T { #[inline] - fn get(list_reader: &ListReader, index: ElementCount32) -> Self { + fn get(list_reader: &ListReader<&A>, index: ElementCount32) -> Self where A: ReaderArena { let offset = (index as u64 * list_reader.step as u64 / BITS_PER_BYTE as u64) as u32; unsafe { let ptr: *const u8 = list_reader.ptr.offset(offset as isize); - ::get(&*(ptr as *const ::Raw)) + (*(ptr as *const WireValue)).get() } } #[inline] - fn get_from_builder(list_builder: &ListBuilder, index: ElementCount32) -> Self { + fn get_from_builder(list_builder: &ListBuilder<&mut A>, index: ElementCount32) -> Self where A: BuilderArena { let offset = (index as u64 * list_builder.step as u64 / BITS_PER_BYTE as u64) as u32; unsafe { - let ptr: *mut ::Raw = list_builder.ptr.offset(offset as isize) as *mut _; - ::get(&*ptr) + let ptr: *mut WireValue = list_builder.ptr.offset(offset as isize) as *mut _; + (*ptr).get() } } #[inline] - fn set(list_builder: &ListBuilder, index: ElementCount32, value: Self) { + fn set(list_builder: &ListBuilder<&mut A>, index: ElementCount32, value: Self) where A: BuilderArena { let offset = (index as u64 * list_builder.step as u64 / BITS_PER_BYTE as u64) as u32; unsafe { - let ptr: *mut ::Raw = list_builder.ptr.offset(offset as isize) as *mut _; - ::set(&mut *ptr, value); + let ptr: *mut WireValue = list_builder.ptr.offset(offset as isize) as *mut _; + (*ptr).set(value); } } @@ -3471,7 +3535,7 @@ impl PrimitiveElement for T { impl PrimitiveElement for bool { #[inline] - fn get(list: &ListReader, index: ElementCount32) -> bool { + fn get(list: &ListReader<&A>, index: ElementCount32) -> bool where A: ReaderArena { let bindex = index as u64 * list.step as u64; unsafe { let b: *const u8 = list.ptr.offset((bindex / BITS_PER_BYTE as u64) as isize); @@ -3479,13 +3543,13 @@ impl PrimitiveElement for bool { } } #[inline] - fn get_from_builder(list: &ListBuilder, index: ElementCount32) -> bool { + fn get_from_builder(list: &ListBuilder<&mut A>, index: ElementCount32) -> bool where A: BuilderArena { let bindex = index as u64 * list.step as u64; let b = unsafe { list.ptr.offset((bindex / BITS_PER_BYTE as u64) as isize) }; unsafe { ((*b) & (1 << (bindex % BITS_PER_BYTE as u64 ))) != 0 } } #[inline] - fn set(list: &ListBuilder, index: ElementCount32, value: bool) { + fn set(list: &ListBuilder<&mut A>, index: ElementCount32, value: bool) where A: BuilderArena { let bindex = index as u64 * list.step as u64; let b = unsafe { list.ptr.offset((bindex / BITS_PER_BYTE as u64) as isize) }; @@ -3497,13 +3561,13 @@ impl PrimitiveElement for bool { impl PrimitiveElement for () { #[inline] - fn get(_list: &ListReader, _index: ElementCount32) -> () { () } + fn get(_list: &ListReader<&A>, _index: ElementCount32) -> () where A: ReaderArena { () } #[inline] - fn get_from_builder(_list: &ListBuilder, _index: ElementCount32) -> () { () } + fn get_from_builder(_list: &ListBuilder<&mut A>, _index: ElementCount32) -> () where A: BuilderArena { () } #[inline] - fn set(_list: &ListBuilder, _index: ElementCount32, _value: ()) { } + fn set(_list: &ListBuilder<&mut A>, _index: ElementCount32, _value: ()) where A: BuilderArena { } fn element_size() -> ElementSize { Void } } diff --git a/capnp/src/private/layout_test.rs b/capnp/src/private/layout_test.rs index 35cbf22d9..c858227e1 100644 --- a/capnp/src/private/layout_test.rs +++ b/capnp/src/private/layout_test.rs @@ -19,9 +19,10 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. +use crate::private::arena::{ReaderArena, NullArena}; use crate::private::layout::PointerReader; -fn test_at_alignments(words: &[crate::Word], verify: &dyn Fn(PointerReader)) { +fn test_at_alignments)>(words: &[crate::Word], verify: &F) { verify(PointerReader::get_root_unchecked(words.as_ptr() as *const u8)); #[cfg(feature="unaligned")] @@ -47,7 +48,7 @@ fn simple_raw_data_struct() { crate::word(0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef)]; test_at_alignments(data, &verify); - fn verify(reader: PointerReader) { + fn verify(reader: PointerReader<&A>) { let reader = reader.get_struct(None).unwrap(); assert_eq!(0xefcdab8967452301u64, reader.get_data_field::(0)); @@ -99,7 +100,7 @@ fn bool_list() { crate::word(0x75, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)]; test_at_alignments(data, &verify); - fn verify(pointer_reader: PointerReader) { + fn verify(pointer_reader: PointerReader<&A>) { use crate::private::layout::PrimitiveElement; use crate::traits::FromPointerReader; @@ -117,7 +118,7 @@ fn bool_list() { assert_eq!(bool::get(&reader, 8), false); assert_eq!(bool::get(&reader, 9), true); - let reader = crate::primitive_list::Reader::::get_from_pointer(&pointer_reader, None).unwrap(); + let reader = crate::primitive_list::Reader::<_, bool>::get_from_pointer(pointer_reader, None).unwrap(); assert_eq!(reader.len(), 10); assert_eq!(reader.get(0), true); @@ -143,7 +144,7 @@ fn struct_size() { ]; test_at_alignments(data, &verify); - fn verify(pointer_reader: PointerReader) { + fn verify(pointer_reader: PointerReader<&A>) { assert_eq!(pointer_reader.total_size().unwrap().word_count, 3); } } @@ -165,7 +166,7 @@ fn struct_list_size() { // the struct tag, because that's what is relevant when the data is copied. test_at_alignments(data, &verify); - fn verify(pointer_reader: PointerReader) { + fn verify(pointer_reader: PointerReader<&A>) { assert_eq!(pointer_reader.total_size().unwrap().word_count, 2); } } @@ -184,7 +185,7 @@ fn empty_struct_list_size() { ]; test_at_alignments(data, &verify); - fn verify(pointer_reader: PointerReader) { + fn verify(pointer_reader: PointerReader<&A>) { assert_eq!(2, pointer_reader.total_size().unwrap().word_count); } } diff --git a/capnp/src/private/mod.rs b/capnp/src/private/mod.rs index 8d6465031..2a4287917 100644 --- a/capnp/src/private/mod.rs +++ b/capnp/src/private/mod.rs @@ -25,7 +25,7 @@ pub mod arena; pub mod capability; -mod primitive; +pub mod primitive; pub mod layout; mod mask; pub mod units; diff --git a/capnp/src/private/primitive.rs b/capnp/src/private/primitive.rs index 3ef93836c..af74cc309 100644 --- a/capnp/src/private/primitive.rs +++ b/capnp/src/private/primitive.rs @@ -1,52 +1,49 @@ pub trait Primitive { - type Raw; + type RawUnaligned; + type RawAligned; /// Reads the value, swapping bytes on big-endian processors. - fn get(raw: &Self::Raw) -> Self; + fn get(raw: &Self::RawUnaligned) -> Self; + + /// Reads the value, swapping bytes on big-endian processors. + fn get_aligned(raw: &Self::RawAligned) -> Self; /// Writes the value, swapping bytes on big-endian processors. - fn set(raw: &mut Self::Raw, value: Self); + fn set(raw: &mut Self::RawUnaligned, value: Self); + + /// Writes the value, swapping bytes on big-endian processors. + fn set_aligned(raw: &mut Self::RawAligned, value: Self); } -#[cfg(feature = "unaligned")] macro_rules! primitive_impl( ($typ:ty, $n:expr) => ( impl Primitive for $typ { - type Raw = [u8; $n]; + type RawUnaligned = [u8; $n]; + type RawAligned = $typ; #[inline] - fn get(raw: &Self::Raw) -> Self { + fn get(raw: &Self::RawUnaligned) -> Self { <$typ>::from_le_bytes(*raw) } #[inline] - fn set(raw: &mut Self::Raw, value: Self) { - *raw = value.to_le_bytes(); + fn get_aligned(raw: &Self::RawAligned) -> Self { + raw.to_le() } - } - ); - ); - -#[cfg(not(feature = "unaligned"))] -macro_rules! primitive_impl( - ($typ:ty, $n:expr) => ( - impl Primitive for $typ { - type Raw = $typ; #[inline] - fn get(raw: &Self::Raw) -> Self { - raw.to_le() + fn set(raw: &mut Self::RawUnaligned, value: Self) { + *raw = value.to_le_bytes(); } #[inline] - fn set(raw: &mut Self::Raw, value: Self) { + fn set_aligned(raw: &mut Self::RawAligned, value: Self) { *raw = value.to_le() } } ); ); - primitive_impl!(u8, 1); primitive_impl!(i8, 1); primitive_impl!(u16, 2); @@ -62,45 +59,95 @@ primitive_impl!(f32, 4); #[cfg(feature = "unaligned")] primitive_impl!(f64, 8); -#[cfg(not(feature = "unaligned"))] impl Primitive for f32 { - type Raw = f32; + type RawUnaligned = [u8; 4]; + type RawAligned = f32; - fn get(raw: &Self::Raw) -> Self { + fn get(raw: &Self::RawUnaligned) -> Self { + f32::from_le_bytes(*raw) + } + + fn get_aligned(raw: &Self::RawAligned) -> Self { f32::from_bits(raw.to_bits().to_le()) } - fn set(raw: &mut Self::Raw, value: Self) { + fn set(raw: &mut Self::RawUnaligned, value: Self) { + *raw = value.to_le_bytes(); + } + + fn set_aligned(raw: &mut Self::RawAligned, value: Self) { *raw = f32::from_bits(value.to_bits().to_le()) } } -#[cfg(not(feature = "unaligned"))] impl Primitive for f64 { - type Raw = f64; + type RawUnaligned = [u8; 8]; + type RawAligned = f64; + + fn get(raw: &Self::RawUnaligned) -> Self { + f64::from_le_bytes(*raw) + } - fn get(raw: &Self::Raw) -> Self { + fn get_aligned(raw: &Self::RawAligned) -> Self { f64::from_bits(raw.to_bits().to_le()) } - fn set(raw: &mut Self::Raw, value: Self) { + fn set(raw: &mut Self::RawUnaligned, value: Self) { + *raw = value.to_le_bytes(); + } + + fn set_aligned(raw: &mut Self::RawAligned, value: Self) { *raw = f64::from_bits(value.to_bits().to_le()) } } +pub trait Alignment { + type Raw; + + fn get(raw: &Self::Raw) -> T; + fn set(raw: &mut Self::Raw, value: T); +} + +pub struct Unaligned; + +impl Alignment for Unaligned { + type Raw = ::RawUnaligned; + + fn get(raw: &Self::Raw) -> T { + ::get(raw) + } + fn set(raw: &mut Self::Raw, value: T) { + ::set(raw, value) + } +} + +pub struct Aligned; + +impl Alignment for Aligned { + type Raw = ::RawAligned; + + fn get(raw: &Self::Raw) -> T { + ::get_aligned(raw) + } + fn set(raw: &mut Self::Raw, value: T) { + ::set_aligned(raw, value) + } +} + /// A value casted directly from a little-endian byte buffer. On big-endian /// processors, the bytes of the value need to be swapped upon reading and writing. #[repr(C)] -pub struct WireValue where T: Primitive { - value: ::Raw, +pub struct WireValue where A: Alignment, T: Primitive { + marker: core::marker::PhantomData, + value: ::Raw, } -impl WireValue where T: Primitive { +impl WireValue where A: Alignment, T: Primitive { /// Reads the value, swapping bytes on big-endian processors. #[inline] - pub fn get(&self) -> T { ::get(&self.value) } + pub fn get(&self) -> T { ::get::(&self.value) } /// Writes the value, swapping bytes on big-endian processors. #[inline] - pub fn set(&mut self, value: T) { ::set(&mut self.value, value) } + pub fn set(&mut self, value: T) { ::set::(&mut self.value, value) } } diff --git a/capnp/src/raw.rs b/capnp/src/raw.rs index c604ae92f..696ef036b 100644 --- a/capnp/src/raw.rs +++ b/capnp/src/raw.rs @@ -20,40 +20,46 @@ //! Functions providing low level access to encoded data. +use crate::private::arena::ReaderArena; use crate::traits::{IntoInternalListReader, IntoInternalStructReader}; /// Gets a slice view of the data section of a struct. -pub fn get_struct_data_section<'a, T>(value: T) -> &'a [u8] - where T: IntoInternalStructReader<'a> +pub fn get_struct_data_section<'a, A, T>(value: T) -> &'a [u8] +where A: ReaderArena + 'a, + T: IntoInternalStructReader<'a, A> { value.into_internal_struct_reader().get_data_section_as_blob() } /// Gets the pointer section as a list. -pub fn get_struct_pointer_section<'a, T>(value: T) -> crate::any_pointer_list::Reader<'a> - where T: IntoInternalStructReader<'a> +pub fn get_struct_pointer_section<'a, A, T>(value: T) -> crate::any_pointer_list::Reader<'a, A> +where A: ReaderArena + 'a, + T: IntoInternalStructReader<'a, A> { crate::any_pointer_list::Reader::new( value.into_internal_struct_reader().get_pointer_section_as_list()) } /// Gets the size of the elements in a list. -pub fn get_list_element_size<'a, T>(value: T) -> crate::private::layout::ElementSize - where T: IntoInternalListReader<'a> +pub fn get_list_element_size<'a, A, T>(value: T) -> crate::private::layout::ElementSize +where A: ReaderArena + 'a, + T: IntoInternalListReader<'a, A> { value.into_internal_list_reader().get_element_size() } /// Gets the number of bits between successive elements in a list. -pub fn get_list_step_size_in_bits<'a, T>(value: T) -> u32 - where T: IntoInternalListReader<'a> +pub fn get_list_step_size_in_bits<'a, A, T>(value: T) -> u32 +where A: ReaderArena + 'a, + T: IntoInternalListReader<'a, A> { value.into_internal_list_reader().get_step_size_in_bits() } /// Gets a slice view of a list, exluding any tag word. -pub fn get_list_bytes<'a, T>(value: T) -> &'a [u8] - where T: IntoInternalListReader<'a> +pub fn get_list_bytes<'a, A: 'a, T>(value: T) -> &'a [u8] +where A: ReaderArena + 'a, + T: IntoInternalListReader<'a, A> { value.into_internal_list_reader().into_raw_bytes() } diff --git a/capnp/src/serialize.rs b/capnp/src/serialize.rs index 5fdda0382..3421508ff 100644 --- a/capnp/src/serialize.rs +++ b/capnp/src/serialize.rs @@ -29,6 +29,7 @@ use core::convert::TryInto; use crate::io::{Read, Write}; use crate::message; +use crate::private::arena::{ReaderArenaImpl, ReadLimiterImpl}; use crate::private::units::BYTES_PER_WORD; use crate::{Error, Result}; @@ -62,9 +63,12 @@ impl <'a> message::ReaderSegments for SliceSegments<'a> { /// /// ALIGNMENT: If the "unaligned" feature is enabled, then there are no alignment requirements on `slice`. /// Otherwise, `slice` must be 8-byte aligned (attempts to read the message will trigger errors). -pub fn read_message_from_flat_slice<'a>(slice: &mut &'a [u8], - options: message::ReaderOptions) - -> Result>> { +pub fn read_message_from_flat_slice<'a, Align>( + slice: &mut &'a [u8], + options: message::ReaderOptions) + -> Result, ReadLimiterImpl, Align>>> + where Align: crate::private::primitive::Alignment +{ let all_bytes = *slice; let mut bytes = *slice; let orig_bytes_len = bytes.len(); @@ -82,7 +86,7 @@ pub fn read_message_from_flat_slice<'a>(slice: &mut &'a [u8], num_words, body_bytes.len() / BYTES_PER_WORD))) } else { *slice = &body_bytes[(num_words * BYTES_PER_WORD)..]; - Ok(message::Reader::new(segment_lengths_builder.into_slice_segments(body_bytes), options)) + Ok(message::Reader::new::(segment_lengths_builder.into_slice_segments(body_bytes), options)) } } @@ -182,8 +186,11 @@ impl SegmentLengthsBuilder { /// Reads a serialized message from a stream with the provided options. /// /// For optimal performance, `read` should be a buffered reader type. -pub fn read_message(mut read: R, options: message::ReaderOptions) -> Result> -where R: Read { +pub fn read_message(mut read: R, options: message::ReaderOptions) + -> Result>> +where R: Read, + A: crate::private::primitive::Alignment, +{ let owned_segments_builder = match read_segment_table(&mut read, options)? { Some(b) => b, None => return Err(Error::failed("Premature end of file".to_string())), @@ -194,8 +201,11 @@ where R: Read { /// Like `read_message()`, but returns None instead of an error if there are zero bytes left in /// `read`. This is useful for reading a stream containing an unknown number of messages -- you /// call this function until it returns None. -pub fn try_read_message(mut read: R, options: message::ReaderOptions) -> Result>> -where R: Read { +pub fn try_read_message(mut read: R, options: message::ReaderOptions) + -> Result>>> +where R: Read, + A: crate::private::primitive::Alignment, +{ let owned_segments_builder = match read_segment_table(&mut read, options)? { Some(b) => b, None => return Ok(None), @@ -691,8 +701,8 @@ pub mod test { const LIST_LENGTH_IN_WORDS: u32 = 5; let mut m = message::Builder::new_default(); { - let root: crate::any_pointer::Builder = m.init_root(); - let _list_builder: crate::primitive_list::Builder = root.initn_as(LIST_LENGTH_IN_WORDS); + let root: crate::any_pointer::Builder<_> = m.init_root(); + let _list_builder: crate::primitive_list::Builder<_, u64> = root.initn_as(LIST_LENGTH_IN_WORDS); } // The message body has a list pointer (one word) and the list (LIST_LENGTH_IN_WORDS words). diff --git a/capnp/src/struct_list.rs b/capnp/src/struct_list.rs index c3d29c007..3e2e32e6e 100644 --- a/capnp/src/struct_list.rs +++ b/capnp/src/struct_list.rs @@ -23,6 +23,7 @@ use core::marker::PhantomData; +use crate::private::arena::{ReaderArena, BuilderArena}; use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, InlineComposite}; use crate::traits::{FromPointerReader, FromPointerBuilder, FromStructBuilder, FromStructReader, HasStructSize, @@ -30,85 +31,90 @@ use crate::traits::{FromPointerReader, FromPointerBuilder, use crate::Result; #[derive(Copy, Clone)] -pub struct Owned where T: for<'a> crate::traits::OwnedStruct<'a> { +pub struct Owned where T: crate::traits::OwnedStruct { marker: PhantomData, } -impl<'a, T> crate::traits::Owned<'a> for Owned where T: for<'b> crate::traits::OwnedStruct<'b> { - type Reader = Reader<'a, T>; - type Builder = Builder<'a, T>; +impl crate::traits::Owned for Owned where T: crate::traits::OwnedStruct { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A, T>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A, T>; } -pub struct Reader<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { +#[derive(Copy, Clone)] +pub struct Reader<'a, A, T> where T: crate::traits::OwnedStruct { marker: PhantomData, - reader: ListReader<'a> -} - -impl <'a, T> Clone for Reader<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - fn clone(&self) -> Reader<'a, T> { - Reader { marker : self.marker, reader : self.reader } - } + reader: ListReader<&'a A> } -impl <'a, T> Copy for Reader<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> {} -impl <'a, T> Reader<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - pub fn new<'b>(reader : ListReader<'b>) -> Reader<'b, T> { - Reader::<'b, T> { reader : reader, marker : PhantomData } +impl <'a, A, T> Reader<'a, A, T> +where T: crate::traits::OwnedStruct + Copy, + A: ReaderArena +{ + pub fn new<'b>(reader: ListReader<&'b A>) -> Reader<'b, A, T> { + Reader { reader: reader, marker: PhantomData } } pub fn len(&self) -> u32 { self.reader.len() } - pub fn iter(self) -> ListIter, >::Reader> { - ListIter::new(self, self.len()) + pub fn iter(self) -> ListIter, ::Reader<'a, A>> { + let len = self.len(); + ListIter::new(self, len) } -} -impl <'a, T> Reader<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - pub fn reborrow<'b>(&'b self) -> Reader<'b, T> { + pub fn reborrow<'b>(&'b self) -> Reader<'b, A, T> { Reader { reader: self.reader, marker: PhantomData } } + + pub fn get(&self, index: u32) -> ::Reader<'a, A> { + assert!(index < self.len()); + FromStructReader::new(self.reader.get_struct_element(index)) + } } -impl <'a, T> FromPointerReader<'a> for Reader<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A, T> FromPointerReader<'a, A> for Reader<'a, A, T> +where T: crate::traits::OwnedStruct, + A: ReaderArena +{ + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Reader { reader: reader.get_list(InlineComposite, default)?, marker: PhantomData }) } } -impl <'a, T> IndexMove>::Reader> for Reader<'a, T> -where T: for<'b> crate::traits::OwnedStruct<'b> { - fn index_move(&self, index: u32) -> >::Reader { +impl <'a, A, T: Copy> IndexMove::Reader<'a, A>> for Reader<'a, A, T> +where T: crate::traits::OwnedStruct, + A: ReaderArena +{ + fn index_move(&self, index: u32) -> ::Reader<'a, A> { self.get(index) } } -impl <'a, T> Reader<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - pub fn get(self, index: u32) -> >::Reader { - assert!(index < self.len()); - FromStructReader::new(self.reader.get_struct_element(index)) - } -} - -impl <'a, T> crate::traits::IntoInternalListReader<'a> for Reader<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - fn into_internal_list_reader(self) -> ListReader<'a> { +impl <'a, A, T> crate::traits::IntoInternalListReader<'a, A> for Reader<'a, A, T> +where T: crate::traits::OwnedStruct, + A: ReaderArena +{ + fn into_internal_list_reader(self) -> ListReader<&'a A> { self.reader } } -pub struct Builder<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { +pub struct Builder<'a, A, T> where T: crate::traits::OwnedStruct { marker: PhantomData, - builder: ListBuilder<'a> + builder: ListBuilder<&'a mut A> } -impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - pub fn new(builder : ListBuilder<'a>) -> Builder<'a, T> { +impl <'a, A, T> Builder<'a, A, T> +where T: crate::traits::OwnedStruct, + A: BuilderArena +{ + pub fn new(builder: ListBuilder<&'a mut A>) -> Builder<'a, A, T> { Builder { builder: builder, marker: PhantomData } } pub fn len(&self) -> u32 { self.builder.len() } - pub fn into_reader(self) -> Reader<'a, T> { + pub fn into_reader(self) -> Reader<'a, A, T> { Reader { marker: PhantomData, reader: self.builder.into_reader(), @@ -119,63 +125,69 @@ impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { /// struct list are allocated inline: if the source struct is larger than the target struct /// (as can happen if it was created with a newer version of the schema), then it will be /// truncated, losing fields. - pub fn set_with_caveats<'b>(&self, index: u32, value: >::Reader) + pub fn set_with_caveats<'b, B>(&mut self, index: u32, value: ::Reader<'b, B>) -> Result<()> - where >::Reader: crate::traits::IntoInternalStructReader<'b> + where B: BuilderArena { use crate::traits::IntoInternalStructReader; - self.builder.get_struct_element(index).copy_content_from(&value.into_internal_struct_reader()) + self.builder.reborrow().get_struct_element(index).copy_content_from(&value.into_internal_struct_reader()) } -} -impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - pub fn reborrow<'b>(&'b mut self) -> Builder<'b, T> { - Builder { builder: self.builder, marker: PhantomData } + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A, T> { + Builder { builder: self.builder.reborrow(), marker: PhantomData } } - } -impl <'a, T> FromPointerBuilder<'a> for Builder<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - fn init_pointer(builder: PointerBuilder<'a>, size: u32) -> Builder<'a, T> { +impl <'a, A, T> FromPointerBuilder<'a, A> for Builder<'a, A, T> +where T: crate::traits::OwnedStruct, + A: BuilderArena +{ + fn init_pointer(builder: PointerBuilder<&'a mut A>, size: u32) -> Builder<'a, A, T> { Builder { marker: PhantomData, builder: builder.init_struct_list( size, - <::Builder as HasStructSize>::struct_size()) + <::Builder<'a, A> as HasStructSize>::struct_size()) } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) + -> Result> + { Ok(Builder { marker: PhantomData, builder: - builder.get_struct_list(<::Builder as HasStructSize>::struct_size(), + builder.get_struct_list(<::Builder<'a, A> as HasStructSize>::struct_size(), default)? }) } } -impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::OwnedStruct<'b> { - pub fn get(self, index: u32) -> >::Builder { +impl <'a, A, T> Builder<'a, A, T> where T: crate::traits::OwnedStruct, A: BuilderArena { + pub fn get(self, index: u32) -> ::Builder<'a, A> { assert!(index < self.len()); FromStructBuilder::new(self.builder.get_struct_element(index)) } } -impl <'a, T> crate::traits::SetPointerBuilder> for Reader<'a, T> - where T: for<'b> crate::traits::OwnedStruct<'b> +impl <'a, A, T> crate::traits::SetPointerBuilder for Reader<'a, A, T> + where T: crate::traits::OwnedStruct, + A: ReaderArena { - fn set_pointer_builder<'b>(pointer: crate::private::layout::PointerBuilder<'b>, - value: Reader<'a, T>, - canonicalize: bool) -> Result<()> { + fn set_pointer_builder<'b, B>(pointer: crate::private::layout::PointerBuilder<&'b mut B>, + value: Reader<'a, A, T>, + canonicalize: bool) -> Result<()> + where B: BuilderArena + { pointer.set_list(&value.reader, canonicalize) } } -impl <'a, T> ::core::iter::IntoIterator for Reader<'a, T> - where T: for<'b> crate::traits::OwnedStruct<'b> +impl <'a, A, T> ::core::iter::IntoIterator for Reader<'a, A, T> +where T: crate::traits::OwnedStruct + Copy, + A: ReaderArena { - type Item = >::Reader; - type IntoIter = ListIter, Self::Item>; + type Item = ::Reader<'a, A>; + type IntoIter = ListIter, Self::Item>; fn into_iter(self) -> Self::IntoIter { self.iter() diff --git a/capnp/src/text.rs b/capnp/src/text.rs index ce26957f9..9bf24a7f6 100644 --- a/capnp/src/text.rs +++ b/capnp/src/text.rs @@ -24,13 +24,14 @@ use core::{convert, str, ops}; use crate::{Error, Result}; +use crate::private::arena::{BuilderArena, ReaderArena}; #[derive(Copy, Clone)] pub struct Owned(()); -impl<'a> crate::traits::Owned<'a> for Owned { - type Reader = Reader<'a>; - type Builder = Builder<'a>; +impl crate::traits::Owned for Owned { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a>; } pub type Reader<'a> = &'a str; @@ -43,8 +44,8 @@ pub fn new_reader<'a>(v : &'a [u8]) -> Result> { } } -impl <'a> crate::traits::FromPointerReader<'a> for Reader<'a> { - fn get_from_pointer(reader: &crate::private::layout::PointerReader<'a>, +impl <'a, A> crate::traits::FromPointerReader<'a, A> for Reader<'a> where A: ReaderArena { + fn get_from_pointer(reader: crate::private::layout::PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { reader.get_text(default) } @@ -110,20 +111,21 @@ impl <'a> convert::AsRef for Builder<'a> { } } -impl <'a> crate::traits::FromPointerBuilder<'a> for Builder<'a> { - fn init_pointer(builder: crate::private::layout::PointerBuilder<'a>, size: u32) -> Builder<'a> { +impl <'a, A> crate::traits::FromPointerBuilder<'a, A> for Builder<'a> where A: BuilderArena { + fn init_pointer(builder: crate::private::layout::PointerBuilder<&'a mut A>, size: u32) -> Builder<'a> { builder.init_text(size) } - fn get_from_pointer(builder: crate::private::layout::PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + fn get_from_pointer(builder: crate::private::layout::PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { builder.get_text(default) } } -impl <'a> crate::traits::SetPointerBuilder> for Reader<'a> { - fn set_pointer_builder<'b>(pointer: crate::private::layout::PointerBuilder<'b>, - value: Reader<'a>, - _canonicalize: bool) - -> Result<()> +impl <'a> crate::traits::SetPointerBuilder for Reader<'a> { + fn set_pointer_builder<'b, A>(pointer: crate::private::layout::PointerBuilder<&'b mut A>, + value: Reader<'a>, + _canonicalize: bool) + -> Result<()> + where A: BuilderArena { pointer.set_text(value); Ok(()) diff --git a/capnp/src/text_list.rs b/capnp/src/text_list.rs index fab73385f..7a89f4839 100644 --- a/capnp/src/text_list.rs +++ b/capnp/src/text_list.rs @@ -22,116 +22,114 @@ //! List of strings containing UTF-8 encoded text. use crate::traits::{FromPointerReader, FromPointerBuilder, IndexMove, ListIter}; +use crate::private::arena::{ReaderArena, BuilderArena}; use crate::private::layout::{ListBuilder, ListReader, Pointer, PointerBuilder, PointerReader}; use crate::Result; #[derive(Copy, Clone)] pub struct Owned; -impl <'a> crate::traits::Owned<'a> for Owned { - type Reader = Reader<'a>; - type Builder = Builder<'a>; +impl crate::traits::Owned for Owned { + type Reader<'a, A: ReaderArena + 'a> = Reader<'a, A>; + type Builder<'a, A: BuilderArena + 'a> = Builder<'a, A>; } #[derive(Clone, Copy)] -pub struct Reader<'a> { - reader: ListReader<'a> +pub struct Reader<'a, A> { + pub reader: ListReader<&'a A> } -impl <'a> Reader<'a> { - pub fn new<'b>(reader : ListReader<'b>) -> Reader<'b> { - Reader::<'b> { reader : reader } - } - +impl <'a, A> Reader<'a, A> where A: ReaderArena { pub fn len(&self) -> u32 { self.reader.len() } - pub fn iter(self) -> ListIter, Result>>{ + pub fn iter(self) -> ListIter, Result>>{ let l = self.len(); ListIter::new(self, l) } } -impl <'a> FromPointerReader<'a> for Reader<'a> { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result> { +impl <'a, A> FromPointerReader<'a, A> for Reader<'a, A> where A: ReaderArena { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Reader { reader : reader.get_list(Pointer, default)? }) } } -impl <'a> IndexMove>> for Reader<'a>{ - fn index_move(&self, index : u32) -> Result> { +impl <'a, A> IndexMove>> for Reader<'a, A> where A: ReaderArena { + fn index_move(&self, index: u32) -> Result> { self.get(index) } } -impl <'a> Reader<'a> { - pub fn get(self, index : u32) -> Result> { +impl <'a, A> Reader<'a, A> where A: ReaderArena { + pub fn get(&self, index: u32) -> Result> { assert!(index < self.len()); self.reader.get_pointer_element(index).get_text(None) } } -impl <'a> crate::traits::IntoInternalListReader<'a> for Reader<'a> { - fn into_internal_list_reader(self) -> ListReader<'a> { +impl <'a, A> crate::traits::IntoInternalListReader<'a, A> for Reader<'a, A> where A: ReaderArena { + fn into_internal_list_reader(self) -> ListReader<&'a A> { self.reader } } -pub struct Builder<'a> { - builder: ListBuilder<'a> +pub struct Builder<'a, A> { + builder: ListBuilder<&'a mut A> } -impl <'a> Builder<'a> { - pub fn new(builder : ListBuilder<'a>) -> Builder<'a> { - Builder { builder : builder } - } - +impl <'a, A> Builder<'a, A> where A: BuilderArena { pub fn len(&self) -> u32 { self.builder.len() } - pub fn set(&mut self, index: u32, value: crate::text::Reader) { - assert!(index < self.len()); - self.builder.borrow().get_pointer_element(index).set_text(value); + pub fn into_reader(self) -> Reader<'a, A> { + Reader { reader: self.builder.into_reader() } } - pub fn into_reader(self) -> Reader<'a> { - Reader { reader: self.builder.into_reader() } + pub fn set(&mut self, index: u32, value: crate::text::Reader) { + assert!(index < self.len()); + self.builder.reborrow().get_pointer_element(index).set_text(value); } - pub fn reborrow<'b>(&'b mut self) -> Builder<'b> { - Builder::<'b> { builder: self.builder.borrow() } + pub fn reborrow<'b>(&'b mut self) -> Builder<'b, A> { + Builder {builder: self.builder.reborrow()} } } - -impl <'a> FromPointerBuilder<'a> for Builder<'a> { - fn init_pointer(builder: PointerBuilder<'a>, size: u32) -> Builder<'a> { +impl <'a, A> FromPointerBuilder<'a, A> for Builder<'a, A> where A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, size : u32) -> Builder<'a, A> { Builder { builder: builder.init_list(Pointer, size) } } - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result> { + + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result> { Ok(Builder { builder: builder.get_list(Pointer, default)? }) } } -impl <'a> Builder<'a> { - pub fn get(self, index: u32) -> Result> { - self.builder.get_pointer_element(index).get_text(None) +impl <'a, A> Builder<'a, A> where A: BuilderArena { + pub fn get(self, index: u32) -> Result> { + assert!(index < self.len()); + self.builder.get_pointer_element(index).get_data(None) } } -impl <'a> crate::traits::SetPointerBuilder> for Reader<'a> { - fn set_pointer_builder<'b>(pointer: crate::private::layout::PointerBuilder<'b>, - value: Reader<'a>, - canonicalize: bool) -> Result<()> { - pointer.set_list(&value.reader, canonicalize) + +impl <'a, A> crate::traits::SetPointerBuilder for Reader<'a, A> where A: ReaderArena { + fn set_pointer_builder<'b, B>(pointer: crate::private::layout::PointerBuilder<&'b mut B>, + value: Reader<'a, A>, + canonicalize: bool) -> Result<()> + where B: BuilderArena + { + pointer.set_list(&value.reader, canonicalize)?; + Ok(()) } } -impl <'a> ::core::iter::IntoIterator for Reader<'a> { +impl <'a, A> ::core::iter::IntoIterator for Reader<'a, A> where A: ReaderArena { type Item = Result>; - type IntoIter = ListIter, Self::Item>; + type IntoIter = ListIter, Self::Item>; fn into_iter(self) -> Self::IntoIter { self.iter() diff --git a/capnp/src/traits.rs b/capnp/src/traits.rs index 8e478512d..4155f59bf 100644 --- a/capnp/src/traits.rs +++ b/capnp/src/traits.rs @@ -20,33 +20,34 @@ // THE SOFTWARE. use crate::{Result}; +use crate::private::arena::{ReaderArena, BuilderArena}; use crate::private::layout::{CapTable, ListReader, StructReader, StructBuilder, StructSize, PointerBuilder, PointerReader}; use core::marker::PhantomData; -pub trait FromStructReader<'a> { - fn new(reader: StructReader<'a>) -> Self; +pub trait FromStructReader<'a, A> { + fn new(reader: StructReader<&'a A>) -> Self; } pub trait HasStructSize { fn struct_size() -> StructSize; } -pub trait IntoInternalStructReader<'a> { - fn into_internal_struct_reader(self) -> StructReader<'a>; +pub trait IntoInternalStructReader<'a, A> { + fn into_internal_struct_reader(self) -> StructReader<&'a A>; } -pub trait FromStructBuilder<'a> { - fn new(struct_builder: StructBuilder<'a>) -> Self; +pub trait FromStructBuilder<'a, A> { + fn new(struct_builder: StructBuilder<&'a mut A>) -> Self; } -pub trait IntoInternalListReader<'a> { - fn into_internal_list_reader(self) -> ListReader<'a>; +pub trait IntoInternalListReader<'a, A> { + fn into_internal_list_reader(self) -> ListReader<&'a A>; } -pub trait FromPointerReader<'a> : Sized { - fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result; +pub trait FromPointerReader<'a, A> : Sized { + fn get_from_pointer(reader: PointerReader<&'a A>, default: Option<&'a [crate::Word]>) -> Result; } /// Associated types hackery that allows us to reason about Cap'n Proto types @@ -55,32 +56,33 @@ pub trait FromPointerReader<'a> : Sized { /// If `Foo` is a Cap'n Proto struct and `Bar` is a Rust-native struct, then /// `foo::Reader<'a>` is to `foo::Owned` as `&'a Bar` is to `Bar`, and /// `foo::Builder<'a>` is to `foo::Owned` as `&'a mut Bar` is to `Bar`. -/// The relationship is formalized by an `impl <'a> capnp::traits::Owned<'a> for foo::Owned`. +/// The relationship is formalized by an `impl capnp::traits::Owned for foo::Owned`. /// Because Cap'n Proto struct layout differs from Rust struct layout, a `foo::Owned` value /// cannot be used for anything interesting on its own; the `foo::Owned` type is useful /// nonetheless as a type parameter, e.g. for a generic container that owns a Cap'n Proto -/// message of type `T: for<'a> capnp::traits::Owned<'a>`. -pub trait Owned<'a> { - type Reader: FromPointerReader<'a> + SetPointerBuilder; - type Builder: FromPointerBuilder<'a>; +/// message of type `T: capnp::traits::Owned`. +pub trait Owned { + type Reader<'a, A: ReaderArena + 'a> : FromPointerReader<'a, A> + SetPointerBuilder; + type Builder<'a, A: BuilderArena + 'a> : FromPointerBuilder<'a, A>; } -pub trait OwnedStruct<'a> { - type Reader: FromStructReader<'a> + SetPointerBuilder + IntoInternalStructReader<'a>; - type Builder: FromStructBuilder<'a> + HasStructSize; +pub trait OwnedStruct { + type Reader<'a, A: ReaderArena + 'a>: FromStructReader<'a, A> + SetPointerBuilder + IntoInternalStructReader<'a, A>; + type Builder<'a, A: BuilderArena + 'a>: FromStructBuilder<'a, A> + HasStructSize; } pub trait Pipelined { type Pipeline; } -pub trait FromPointerBuilder<'a> : Sized { - fn init_pointer(builder: PointerBuilder<'a>, length: u32) -> Self; - fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result; +pub trait FromPointerBuilder<'a, A> : Sized where A: BuilderArena { + fn init_pointer(builder: PointerBuilder<&'a mut A>, length: u32) -> Self; + fn get_from_pointer(builder: PointerBuilder<&'a mut A>, default: Option<&'a [crate::Word]>) -> Result; } -pub trait SetPointerBuilder { - fn set_pointer_builder<'a>(builder: PointerBuilder<'a>, from: Self, canonicalize: bool) -> Result<()>; +pub trait SetPointerBuilder { + fn set_pointer_builder<'a, A>(builder: PointerBuilder<&'a mut A>, from: Self, canonicalize: bool) -> Result<()> + where A: BuilderArena; } pub trait Imbue<'a> { diff --git a/capnp/tests/total_size.rs b/capnp/tests/total_size.rs index bc79b37d5..0b635fee3 100644 --- a/capnp/tests/total_size.rs +++ b/capnp/tests/total_size.rs @@ -8,7 +8,7 @@ pub fn total_size_out_of_bounds() { let segments = &[capnp::Word::words_to_bytes(segment)]; let segment_array = capnp::message::SegmentArray::new(segments); let message = capnp::message::Reader::new(segment_array, Default::default()); - let root: capnp::any_pointer::Reader = message.get_root().unwrap(); + let root: capnp::any_pointer::Reader<_> = message.get_root().unwrap(); // At one point, this failed in miri with: // error: pointer computed at offset 33554448, outside bounds of allocation Runtime(702) which has size 16 diff --git a/capnpc/src/codegen.rs b/capnpc/src/codegen.rs index 92a8c8394..f909fb6fc 100644 --- a/capnpc/src/codegen.rs +++ b/capnpc/src/codegen.rs @@ -24,6 +24,7 @@ use std::collections::HashSet; use capnp; use capnp::Error; +use capnp::private::arena::{ReaderArena, ReaderArenaImpl, ReadLimiterImpl}; use crate::{convert_io_err}; use crate::pointer_constants::generate_pointer_constant; @@ -31,20 +32,20 @@ use crate::schema_capnp; use crate::codegen_types::{ Leaf, RustTypeInfo, RustNodeInfo, TypeParameterTexts, do_branding }; use self::FormattedText::{Indent, Line, Branch, BlankLine}; -pub struct GeneratorContext<'a> { - pub request: schema_capnp::code_generator_request::Reader<'a>, - pub node_map: collections::hash_map::HashMap>, +pub struct GeneratorContext<'a, A> where A: ReaderArena { + pub request: schema_capnp::code_generator_request::Reader<'a, A>, + pub node_map: collections::hash_map::HashMap>, pub scope_map: collections::hash_map::HashMap>, } -impl <'a> GeneratorContext<'a> { +impl <'a> GeneratorContext<'a, ReaderArenaImpl> { pub fn new( message:&'a capnp::message::Reader) - -> ::capnp::Result> + -> ::capnp::Result { let mut gen = GeneratorContext { request : message.get_root()?, - node_map: collections::hash_map::HashMap::>::new(), + node_map: collections::hash_map::HashMap::>>::new(), scope_map: collections::hash_map::HashMap::>::new(), }; @@ -80,7 +81,9 @@ impl <'a> GeneratorContext<'a> { } Ok(gen) } +} +impl <'a, A> GeneratorContext<'a, A> where A: ReaderArena { fn get_last_name<'b>(&'b self, id: u64) -> ::capnp::Result<&'b str> { match self.scope_map.get(&id) { None => Err(Error::failed(format!("node not found: {}", id))), @@ -233,7 +236,7 @@ fn module_name(camel_case: &str) -> String { const NAME_ANNOTATION_ID: u64 = 0xc2fe4c6d100166d0; const PARENT_MODULE_ANNOTATION_ID: u64 = 0xabee386cd1450364; -fn name_annotation_value(annotation: schema_capnp::annotation::Reader) -> capnp::Result<&str> { +fn name_annotation_value(annotation: schema_capnp::annotation::Reader) -> capnp::Result<&str> { if let schema_capnp::value::Text(t) = annotation.get_value()?.which()? { let name = t?; for c in name.chars() { @@ -248,7 +251,7 @@ fn name_annotation_value(annotation: schema_capnp::annotation::Reader) -> capnp: } } -fn get_field_name(field: schema_capnp::field::Reader) -> capnp::Result<&str> { +fn get_field_name(field: schema_capnp::field::Reader) -> capnp::Result<&str> { for annotation in field.get_annotations()?.iter() { if annotation.get_id() == NAME_ANNOTATION_ID { return name_annotation_value(annotation); @@ -257,7 +260,7 @@ fn get_field_name(field: schema_capnp::field::Reader) -> capnp::Result<&str> { field.get_name() } -fn get_enumerant_name(enumerant: schema_capnp::enumerant::Reader) -> capnp::Result<&str> { +fn get_enumerant_name(enumerant: schema_capnp::enumerant::Reader) -> capnp::Result<&str> { for annotation in enumerant.get_annotations()?.iter() { if annotation.get_id() == NAME_ANNOTATION_ID { if annotation.get_id() == NAME_ANNOTATION_ID { @@ -268,7 +271,7 @@ fn get_enumerant_name(enumerant: schema_capnp::enumerant::Reader) -> capnp::Resu enumerant.get_name() } -fn get_parent_module(annotation: schema_capnp::annotation::Reader) -> capnp::Result> { +fn get_parent_module(annotation: schema_capnp::annotation::Reader) -> capnp::Result> { if let schema_capnp::value::Text(t) = annotation.get_value()?.which()? { let module = t?; Ok(module.split("::").map(|x| x.to_string()).collect()) @@ -292,7 +295,7 @@ fn capnp_name_to_rust_name(capnp_name: &str, name_kind: NameKind) -> String { } } -fn populate_scope_map(node_map: &collections::hash_map::HashMap, +fn populate_scope_map(node_map: &collections::hash_map::HashMap>, scope_map: &mut collections::hash_map::HashMap>, mut ancestor_scope_names: Vec, mut current_node_name: String, @@ -366,7 +369,7 @@ fn populate_scope_map(node_map: &collections::hash_map::HashMap ::capnp::Result> { +fn prim_default(value: &schema_capnp::value::Reader) -> ::capnp::Result> { use crate::schema_capnp::value; match value.which()? { value::Bool(false) | @@ -400,8 +403,8 @@ fn prim_default(value: &schema_capnp::value::Reader) -> ::capnp::Result, + field: &schema_capnp::field::Reader, is_reader: bool, is_fn: bool) -> ::capnp::Result<(String, FormattedText, Option)> { @@ -412,9 +415,9 @@ pub fn getter_text(gen: &GeneratorContext, let the_mod = gen.scope_map[&group.get_type_id()].join("::"); let mut result_type = if is_reader { - format!("{}::Reader<'a>", the_mod) + format!("{}::Reader<'a, A>", the_mod) } else { - format!("{}::Builder<'a>", the_mod) + format!("{}::Builder<'a, A>", the_mod) }; if is_fn { @@ -433,7 +436,7 @@ pub fn getter_text(gen: &GeneratorContext, let mut default_decl = None; let offset = reg_field.get_offset() as usize; let module_string = if is_reader { "Reader" } else { "Builder" }; - let module = if is_reader { Leaf::Reader("'a") } else { Leaf::Builder("'a") }; + let module = if is_reader { Leaf::Reader("'a", "A") } else { Leaf::Builder("'a", "A") }; let member = camel_to_snake_case(&*format!("{}", module_string)); fn primitive_case(typ: &str, member:String, @@ -524,7 +527,7 @@ pub fn getter_text(gen: &GeneratorContext, if is_reader { Line(format!( - "::capnp::traits::FromPointerReader::get_from_pointer(&self.{}.get_pointer_field({}), {})", + "::capnp::traits::FromPointerReader::get_from_pointer(self.{}.get_pointer_field({}), {})", member, offset, default)) } else { Line(format!("::capnp::traits::FromPointerBuilder::get_from_pointer(self.{}.get_pointer_field({}), {})", @@ -555,14 +558,14 @@ pub fn getter_text(gen: &GeneratorContext, } } -fn zero_fields_of_group(gen: &GeneratorContext, node_id: u64) -> ::capnp::Result { +fn zero_fields_of_group(gen: &GeneratorContext, node_id: u64) -> ::capnp::Result { use crate::schema_capnp::{node, field, type_}; match gen.node_map[&node_id].which()? { node::Struct(st) => { let mut result = Vec::new(); if st.get_discriminant_count() != 0 { result.push( - Line(format!("self.builder.set_data_field::({}, 0);", + Line(format!("self.builder.reborrow().set_data_field::({}, 0);", st.get_discriminant_offset()))); } let fields = st.get_fields()?; @@ -587,7 +590,7 @@ fn zero_fields_of_group(gen: &GeneratorContext, node_id: u64) -> ::capnp::Result type_::Uint64(()) | type_::Float32(()) | type_::Float64(()) => { let line = Line(format!( "self.builder.set_data_field::<{0}>({1}, 0{0});", - slot.get_type()?.type_string(gen, Leaf::Builder("'a"))?, + slot.get_type()?.type_string(gen, Leaf::Builder("'a", "A"))?, slot.get_offset())); // PERF could dedup more efficiently if !result.contains(&line) { result.push(line) } @@ -602,7 +605,7 @@ fn zero_fields_of_group(gen: &GeneratorContext, node_id: u64) -> ::capnp::Result type_::AnyPointer(_) | type_::Interface(_) // Is this the right thing to do for interfaces? => { - let line = Line(format!("self.builder.get_pointer_field({}).clear();", + let line = Line(format!("self.builder.reborrow().get_pointer_field({}).clear();", slot.get_offset())); // PERF could dedup more efficiently if !result.contains(&line) { result.push(line) } @@ -617,9 +620,9 @@ fn zero_fields_of_group(gen: &GeneratorContext, node_id: u64) -> ::capnp::Result } } -fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, +fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, styled_name: &str, - field: &schema_capnp::field::Reader) -> ::capnp::Result { + field: &schema_capnp::field::Reader) -> ::capnp::Result { use crate::schema_capnp::*; @@ -645,6 +648,7 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, let mut setter_generic_param = String::new(); let mut return_result = false; let mut result = Vec::new(); + let mut initter_self = "self"; let (maybe_reader_type, maybe_builder_type) : (Option, Option) = match field.which()? { field::Group(group) => { @@ -652,10 +656,11 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, let the_mod = scope.join("::"); initter_interior.push(zero_fields_of_group(gen, group.get_type_id())?); + initter_self = "mut self"; initter_interior.push(Line(format!("::capnp::traits::FromStructBuilder::new(self.builder)"))); - (None, Some(format!("{}::Builder<'a>", the_mod))) + (None, Some(format!("{}::Builder<'a, A>", the_mod))) } field::Slot(reg_field) => { let offset = reg_field.get_offset() as usize; @@ -678,7 +683,7 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, (Some("bool".to_string()), None) } _ if typ.is_prim()? => { - let tstr = typ.type_string(gen, Leaf::Reader("'a"))?; + let tstr = typ.type_string(gen, Leaf::Reader("'a", "A"))?; match prim_default(®_field.get_default_value()?)? { None => { setter_interior.push(Line(format!("self.builder.set_data_field::<{}>({}, value);", @@ -693,7 +698,7 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, (Some(tstr), None) } type_::Text(()) => { - setter_interior.push(Line(format!("self.builder.get_pointer_field({}).set_text(value);", + setter_interior.push(Line(format!("self.builder.reborrow().get_pointer_field({}).set_text(value);", offset))); initter_interior.push(Line(format!("self.builder.get_pointer_field({}).init_text(size)", offset))); @@ -701,7 +706,7 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, (Some("::capnp::text::Reader".to_string()), Some("::capnp::text::Builder<'a>".to_string())) } type_::Data(()) => { - setter_interior.push(Line(format!("self.builder.get_pointer_field({}).set_data(value);", + setter_interior.push(Line(format!("self.builder.reborrow().get_pointer_field({}).set_data(value);", offset))); initter_interior.push(Line(format!("self.builder.get_pointer_field({}).init_data(size)", offset))); @@ -711,7 +716,7 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, type_::List(ot1) => { return_result = true; setter_interior.push( - Line(format!("::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field({}), value, false)", + Line(format!("::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field({}), value, false)", offset))); initter_params.push("size: u32"); @@ -721,12 +726,12 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, match ot1.get_element_type()?.which()? { type_::List(_) => { setter_generic_param = "<'b>".to_string(); - (Some(reg_field.get_type()?.type_string(gen, Leaf::Reader("'b"))?), - Some(reg_field.get_type()?.type_string(gen, Leaf::Builder("'a"))?)) + (Some(reg_field.get_type()?.type_string(gen, Leaf::Reader("'b", "B"))?), + Some(reg_field.get_type()?.type_string(gen, Leaf::Builder("'a", "A"))?)) } _ => - (Some(reg_field.get_type()?.type_string(gen, Leaf::Reader("'a"))?), - Some(reg_field.get_type()?.type_string(gen, Leaf::Builder("'a"))?)) + (Some(reg_field.get_type()?.type_string(gen, Leaf::Reader("'a", "A"))?), + Some(reg_field.get_type()?.type_string(gen, Leaf::Builder("'a", "A"))?)) } } type_::Enum(e) => { @@ -739,24 +744,23 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, } type_::Struct(_) => { return_result = true; - setter_generic_param = "<'b>".to_string(); + setter_generic_param = "<'b, B: ::capnp::private::arena::ReaderArena >".to_string(); initter_interior.push( Line(format!("::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field({}), 0)", offset))); if typ.is_branded()? { setter_interior.push( Line(format!( - "<{} as ::capnp::traits::SetPointerBuilder<{}>>::set_pointer_builder(self.builder.get_pointer_field({}), value, false)", - typ.type_string(gen, Leaf::Reader("'b"))?, - typ.type_string(gen, Leaf::Builder("'b"))?, + "<{} as ::capnp::traits::SetPointerBuilder>::set_pointer_builder(self.builder.reborrow().get_pointer_field({}), value, false)", + typ.type_string(gen, Leaf::Reader("'b", "B"))?, offset))); - (Some(typ.type_string(gen, Leaf::Reader("'b"))?), - Some(typ.type_string(gen, Leaf::Builder("'a"))?)) + (Some(typ.type_string(gen, Leaf::Reader("'b", "B"))?), + Some(typ.type_string(gen, Leaf::Builder("'a", "A"))?)) } else { setter_interior.push( - Line(format!("::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field({}), value, false)", offset))); - (Some(reg_field.get_type()?.type_string(gen, Leaf::Reader("'b"))?), - Some(reg_field.get_type()?.type_string(gen, Leaf::Builder("'a"))?)) + Line(format!("::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field({}), value, false)", offset))); + (Some(reg_field.get_type()?.type_string(gen, Leaf::Reader("'b", "B"))?), + Some(reg_field.get_type()?.type_string(gen, Leaf::Builder("'a", "A"))?)) } } type_::Interface(_) => { @@ -769,12 +773,11 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, if typ.is_parameter()? { initter_interior.push(Line(format!("::capnp::any_pointer::Builder::new(self.builder.get_pointer_field({})).init_as()", offset))); setter_generic_param = format!( - ">", - typ.type_string(gen, Leaf::Builder("'a"))?); + ""); setter_interior.push(Line(format!("::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field({}), value, false)", offset))); return_result = true; - let builder_type = typ.type_string(gen, Leaf::Builder("'a"))?; + let builder_type = typ.type_string(gen, Leaf::Builder("'a", "A"))?; result.push(Line("#[inline]".to_string())); result.push(Line(format!("pub fn initn_{}(self, length: u32) -> {} {{", @@ -791,7 +794,7 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, offset))); initter_interior.push(Line("result.clear();".to_string())); initter_interior.push(Line("result".to_string())); - (None, Some("::capnp::any_pointer::Builder<'a>".to_string())) + (None, Some("::capnp::any_pointer::Builder<'a, A>".to_string())) } } _ => return Err(Error::failed(format!("unrecognized type"))), @@ -815,8 +818,8 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, Some(builder_type) => { result.push(Line("#[inline]".to_string())); let args = initter_params.join(", "); - result.push(Line(format!("pub fn init_{}(self, {}) -> {} {{", - styled_name, args, builder_type))); + result.push(Line(format!("pub fn init_{}({}, {}) -> {} {{", + styled_name, initter_self, args, builder_type))); result.push(Indent(Box::new(Branch(initter_interior)))); result.push(Line("}".to_string())); } @@ -827,9 +830,9 @@ fn generate_setter(gen: &GeneratorContext, discriminant_offset: u32, // return (the 'Which' enum, the 'which()' accessor, typedef, default_decls) -fn generate_union(gen: &GeneratorContext, +fn generate_union(gen: &GeneratorContext, discriminant_offset: u32, - fields: &[schema_capnp::field::Reader], + fields: &[schema_capnp::field::Reader], is_reader: bool, params: &TypeParameterTexts) -> ::capnp::Result<(FormattedText, FormattedText, FormattedText, Vec)> @@ -916,7 +919,7 @@ fn generate_union(gen: &GeneratorContext, let concrete_type = format!("Which{}{}", if is_reader {"Reader"} else {"Builder"}, - if ty_params.len() > 0 { format!("<'a,{}>", params.params) } else { "".to_string() }); + if ty_params.len() > 0 { format!("<'a,A,{}>", params.params) } else { "".to_string() }); let typedef = Line(format!("pub type {} = Which{};", @@ -941,13 +944,14 @@ fn generate_union(gen: &GeneratorContext, fn generate_haser(discriminant_offset: u32, styled_name: &str, - field: &schema_capnp::field::Reader, + field: &schema_capnp::field::Reader, is_reader: bool) -> ::capnp::Result { use crate::schema_capnp::*; let mut result = Vec::new(); let mut interior = Vec::new(); let member = if is_reader { "reader" } else { "builder" }; + let member2 = if is_reader { member } else { "builder.reborrow_as_reader()" }; let discriminant_value = field.get_discriminant_value(); if discriminant_value != field::NO_DISCRIMINANT { @@ -966,7 +970,7 @@ fn generate_haser(discriminant_offset: u32, type_::AnyPointer(_) => { interior.push( Line(format!("!self.{}.get_pointer_field({}).is_null()", - member, reg_field.get_offset()))); + member2, reg_field.get_offset()))); result.push( Line(format!("pub fn has_{}(&self) -> bool {{", styled_name))); result.push( @@ -981,8 +985,8 @@ fn generate_haser(discriminant_offset: u32, Ok(Branch(result)) } -fn generate_pipeline_getter(gen: &GeneratorContext, - field: schema_capnp::field::Reader) -> ::capnp::Result { +fn generate_pipeline_getter(gen: &GeneratorContext, + field: schema_capnp::field::Reader) -> ::capnp::Result { use crate::schema_capnp::{field, type_}; let name = get_field_name(field)?; @@ -1031,8 +1035,8 @@ fn generate_pipeline_getter(gen: &GeneratorContext, // We need this to work around the fact that Rust does not allow typedefs // with unused type parameters. -fn get_ty_params_of_brand(gen: &GeneratorContext, - brand: crate::schema_capnp::brand::Reader<>) -> ::capnp::Result +fn get_ty_params_of_brand(gen: &GeneratorContext, + brand: crate::schema_capnp::brand::Reader) -> ::capnp::Result { let mut acc = HashSet::new(); get_ty_params_of_brand_helper(gen, &mut acc, brand)?; @@ -1047,9 +1051,9 @@ fn get_ty_params_of_brand(gen: &GeneratorContext, Ok(result) } -fn get_ty_params_of_type_helper(gen: &GeneratorContext, +fn get_ty_params_of_type_helper(gen: &GeneratorContext, accumulator: &mut HashSet<(u64, u16)>, - typ: crate::schema_capnp::type_::Reader<>) + typ: crate::schema_capnp::type_::Reader) -> ::capnp::Result<()> { use crate::schema_capnp::type_; @@ -1093,9 +1097,9 @@ fn get_ty_params_of_type_helper(gen: &GeneratorContext, Ok(()) } -fn get_ty_params_of_brand_helper(gen: &GeneratorContext, +fn get_ty_params_of_brand_helper(gen: &GeneratorContext, accumulator: &mut HashSet<(u64, u16)>, - brand: crate::schema_capnp::brand::Reader<>) + brand: crate::schema_capnp::brand::Reader) -> ::capnp::Result<()> { for scope in brand.get_scopes()?.iter() { @@ -1122,7 +1126,7 @@ fn get_ty_params_of_brand_helper(gen: &GeneratorContext, Ok(()) } -fn generate_node(gen: &GeneratorContext, +fn generate_node(gen: &GeneratorContext, node_id: u64, node_name: &str, // Ugh. We need this to deal with the anonymous Params and Results @@ -1248,7 +1252,7 @@ fn generate_node(gen: &GeneratorContext, let builder_struct_size = Branch(vec!( - Line(format!("impl <'a,{0}> ::capnp::traits::HasStructSize for Builder<'a,{0}> {1} {{", + Line(format!("impl <'a,A,{0}> ::capnp::traits::HasStructSize for Builder<'a,A,{0}> {1} {{", params.params, params.where_clause)), Indent(Box::new( Branch(vec!(Line("#[inline]".to_string()), @@ -1270,14 +1274,14 @@ fn generate_node(gen: &GeneratorContext, let from_pointer_builder_impl = Branch(vec![ - Line(format!("impl <'a,{0}> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,{0}> {1} {{", params.params, params.where_clause)), + Line(format!("impl <'a, A, {0}> ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, {0}> where A: ::capnp::private::arena::BuilderArena {1} {{", params.params, params.where_clause)), Indent( Box::new( Branch(vec!( - Line(format!("fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,{}> {{", params.params)), + Line(format!("fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, {}> {{", params.params)), Indent(Box::new(Line("::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE))".to_string()))), Line("}".to_string()), - Line(format!("fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> {{", params.params)), + Line(format!("fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> {{", params.params)), Indent(Box::new(Line("::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?))".to_string()))), Line("}".to_string()))))), Line("}".to_string()), @@ -1289,8 +1293,8 @@ fn generate_node(gen: &GeneratorContext, Branch(vec!( Line("#[derive(Copy, Clone)]".into()), Line("pub struct Owned;".to_string()), - Line("impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; }".to_string()), - Line("impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; }".to_string()), + Line("impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; }".to_string()), + Line("impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; }".to_string()), Line("impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; }".to_string()) )) } else { @@ -1308,9 +1312,8 @@ fn generate_node(gen: &GeneratorContext, )) }), BlankLine, - Line("#[derive(Clone, Copy)]".to_string()), (if !is_generic { - Line("pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> }".to_string()) + Line("pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> }".to_string()) } else { Branch(vec!( Line(format!("pub struct Reader<'a,{}> {} {{", params.params, params.where_clause)), @@ -1321,41 +1324,45 @@ fn generate_node(gen: &GeneratorContext, Line("}".to_string()) )) }), + BlankLine, + Line("impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } }".to_string()), + Line("impl <'a, A> Copy for Reader<'a,A> {}".to_string()), + BlankLine, Branch(vec!( - Line(format!("impl <'a,{0}> ::capnp::traits::HasTypeId for Reader<'a,{0}> {1} {{", + Line(format!("impl <'a, A, {0}> ::capnp::traits::HasTypeId for Reader<'a,A,{0}> {1} {{", params.params, params.where_clause)), Indent(Box::new(Branch(vec!(Line("#[inline]".to_string()), Line("fn type_id() -> u64 { _private::TYPE_ID }".to_string()))))), Line("}".to_string()))), - Line(format!("impl <'a,{0}> ::capnp::traits::FromStructReader<'a> for Reader<'a,{0}> {1} {{", + Line(format!("impl <'a,A,{0}> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, {0}> where A: ::capnp::private::arena::ReaderArena {1} {{", params.params, params.where_clause)), Indent( Box::new(Branch(vec!( - Line(format!("fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,{}> {{", params.params)), + Line(format!("fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,{}> {{", params.params)), Indent(Box::new(Line(format!("Reader {{ reader, {} }}", params.phantom_data_value)))), Line("}".to_string()))))), Line("}".to_string()), BlankLine, - Line(format!("impl <'a,{0}> ::capnp::traits::FromPointerReader<'a> for Reader<'a,{0}> {1} {{", + Line(format!("impl <'a,A,{0}> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,{0}> where A: ::capnp::private::arena::ReaderArena {1} {{", params.params, params.where_clause)), Indent( Box::new(Branch(vec!( - Line(format!("fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> {{",params.params)), + Line(format!("fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> {{",params.params)), Indent(Box::new(Line("::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?))".to_string()))), Line("}".to_string()))))), Line("}".to_string()), BlankLine, - Line(format!("impl <'a,{0}> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,{0}> {1} {{", + Line(format!("impl <'a,A,{0}> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,{0}> {1} {{", params.params, params.where_clause)), Indent( Box::new(Branch(vec!( - Line("fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> {".to_string()), + Line("fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> {".to_string()), Indent(Box::new(Line("self.reader".to_string()))), Line("}".to_string()))))), Line("}".to_string()), BlankLine, - Line(format!("impl <'a,{0}> ::capnp::traits::Imbue<'a> for Reader<'a,{0}> {1} {{", + Line(format!("impl <'a,A,{0}> ::capnp::traits::Imbue<'a> for Reader<'a,A,{0}> where A: ::capnp::private::arena::ReaderArena {1} {{", params.params, params.where_clause)), Indent( Box::new(Branch(vec!( @@ -1364,10 +1371,10 @@ fn generate_node(gen: &GeneratorContext, Line("}".to_string()))))), Line("}".to_string()), BlankLine, - Line(format!("impl <'a,{0}> Reader<'a,{0}> {1} {{", params.params, params.where_clause)), + Line(format!("impl <'a,A,{0}> Reader<'a,A,{0}> where A: ::capnp::private::arena::ReaderArena {1} {{", params.params, params.where_clause)), Indent( Box::new(Branch(vec![ - Line(format!("pub fn reborrow(&self) -> Reader<{}> {{",params.params)), + Line(format!("pub fn reborrow(&self) -> Reader {{", params.params)), Indent(Box::new(Line("Reader { .. *self }".to_string()))), Line("}".to_string()), BlankLine, @@ -1378,7 +1385,7 @@ fn generate_node(gen: &GeneratorContext, Line("}".to_string()), BlankLine, (if !is_generic { - Line("pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> }".to_string()) + Line("pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> }".to_string()) } else { Branch(vec!( Line(format!("pub struct Builder<'a,{}> {} {{", @@ -1392,23 +1399,23 @@ fn generate_node(gen: &GeneratorContext, }), builder_struct_size, Branch(vec!( - Line(format!("impl <'a,{0}> ::capnp::traits::HasTypeId for Builder<'a,{0}> {1} {{", + Line(format!("impl <'a,A,{0}> ::capnp::traits::HasTypeId for Builder<'a,A,{0}> {1} {{", params.params, params.where_clause)), Indent(Box::new(Branch(vec!( Line("#[inline]".to_string()), Line("fn type_id() -> u64 { _private::TYPE_ID }".to_string()))))), Line("}".to_string()))), Line(format!( - "impl <'a,{0}> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,{0}> {1} {{", + "impl <'a, A, {0}> ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,{0}> where A: ::capnp::private::arena::BuilderArena {1} {{", params.params, params.where_clause)), Indent( Box::new(Branch(vec!( - Line(format!("fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, {}> {{", params.params)), + Line(format!("fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, {}> {{", params.params)), Indent(Box::new(Line(format!("Builder {{ builder, {} }}", params.phantom_data_value)))), Line("}".to_string()))))), Line("}".to_string()), BlankLine, - Line(format!("impl <'a,{0}> ::capnp::traits::ImbueMut<'a> for Builder<'a,{0}> {1} {{", + Line(format!("impl <'a,A,{0}> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,{0}> where A: ::capnp::private::arena::BuilderArena {1} {{", params.params, params.where_clause)), Indent( Box::new(Branch(vec!( @@ -1420,27 +1427,27 @@ fn generate_node(gen: &GeneratorContext, from_pointer_builder_impl, Line(format!( - "impl <'a,{0}> ::capnp::traits::SetPointerBuilder> for Reader<'a,{0}> {1} {{", + "impl <'a, A, {0}> ::capnp::traits::SetPointerBuilder for Reader<'a, A, {0}> where A: ::capnp::private::arena::ReaderArena {1} {{", params.params, params.where_clause)), - Indent(Box::new(Line(format!("fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,{}>, canonicalize: bool) -> ::capnp::Result<()> {{ pointer.set_struct(&value.reader, canonicalize) }}", params.params)))), + Indent(Box::new(Line(format!("fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, {}>, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena {{ pointer.set_struct(&value.reader, canonicalize) }}", params.params)))), Line("}".to_string()), BlankLine, - Line(format!("impl <'a,{0}> Builder<'a,{0}> {1} {{", params.params, params.where_clause)), + Line(format!("impl <'a, A, {0}> Builder<'a, A, {0}> where A: ::capnp::private::arena::BuilderArena {1} {{", params.params, params.where_clause)), Indent( Box::new(Branch(vec![ - Line(format!("pub fn into_reader(self) -> Reader<'a,{}> {{", params.params)), + Line(format!("pub fn into_reader(self) -> Reader<'a,A, {}> {{", params.params)), Indent(Box::new(Line("::capnp::traits::FromStructReader::new(self.builder.into_reader())".to_string()))), Line("}".to_string()), - Line(format!("pub fn reborrow(&mut self) -> Builder<{}> {{", params.params)), - Indent(Box::new(Line("Builder { .. *self }".to_string()))), + Line(format!("pub fn reborrow(&mut self) -> Builder {{", params.params)), + Indent(Box::new(Line("Builder { builder: self.builder.reborrow() }".to_string()))), Line("}".to_string()), - Line(format!("pub fn reborrow_as_reader(&self) -> Reader<{}> {{", params.params)), - Indent(Box::new(Line("::capnp::traits::FromStructReader::new(self.builder.into_reader())".to_string()))), + Line(format!("pub fn reborrow_as_reader(&self) -> Reader {{", params.params)), + Indent(Box::new(Line("::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader())".to_string()))), Line("}".to_string()), BlankLine, Line("pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> {".to_string()), - Indent(Box::new(Line("self.builder.into_reader().total_size()".to_string()))), + Indent(Box::new(Line("self.builder.reborrow_as_reader().total_size()".to_string()))), Line("}".to_string()) ]))), Indent(Box::new(Branch(builder_members))), diff --git a/capnpc/src/codegen_types.rs b/capnpc/src/codegen_types.rs index a6545c668..4bbd2d474 100644 --- a/capnpc/src/codegen_types.rs +++ b/capnpc/src/codegen_types.rs @@ -21,14 +21,15 @@ use crate::schema_capnp::{brand, node, type_}; use capnp::Error; +use capnp::private::arena::ReaderArena; use crate::codegen; use crate::codegen::{GeneratorContext}; use std::collections::hash_map::HashMap; #[derive(Copy,Clone,PartialEq)] pub enum Leaf { - Reader(&'static str), - Builder(&'static str), + Reader(&'static str, &'static str), // lifetime parameter, arena parameter + Builder(&'static str, &'static str), // lifetime parameter, arena parameter Owned, Client, Server, @@ -39,8 +40,8 @@ pub enum Leaf { impl ::std::fmt::Display for Leaf { fn fmt(&self, fmt:&mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> { let display_string = match self { - &Leaf::Reader(lt) => format!("Reader<{}>", lt), - &Leaf::Builder(lt) => format!("Builder<{}>", lt), + &Leaf::Reader(lt, ap) => format!("Reader<{},{}>", lt, ap), + &Leaf::Builder(lt, ap) => format!("Builder<{},{}>", lt, ap), &Leaf::Owned => "Owned".to_string(), &Leaf::Client => "Client".to_string(), &Leaf::Server => "Server".to_string(), @@ -54,8 +55,8 @@ impl ::std::fmt::Display for Leaf { impl Leaf { fn bare_name(&self) -> &'static str { match self { - &Leaf::Reader(_) => "Reader", - &Leaf::Builder(_) => "Builder", + &Leaf::Reader(..) => "Reader", + &Leaf::Builder(..) => "Builder", &Leaf::Owned => "Owned", &Leaf::Client => "Client", &Leaf::Server => "Server", @@ -66,7 +67,7 @@ impl Leaf { fn _have_lifetime(&self) -> bool { match self { - &Leaf::Reader(_) | &Leaf::Builder(_) => true, + &Leaf::Reader(..) | &Leaf::Builder(..) => true, &Leaf::Owned | &Leaf::Client | &Leaf::Server | &Leaf::ServerDispatch | &Leaf::Pipeline => false, } } @@ -84,7 +85,7 @@ pub struct TypeParameterTexts { // this is a collection of helpers acting on a "Node" (most of them are Type definitions) pub trait RustNodeInfo { - fn parameters_texts(&self, gen: &crate::codegen::GeneratorContext, + fn parameters_texts(&self, gen: &crate::codegen::GeneratorContext, parent_node_id: Option) -> TypeParameterTexts; } @@ -94,11 +95,11 @@ pub trait RustTypeInfo { fn is_prim(&self) -> Result; fn is_parameter(&self) -> Result; fn is_branded(&self) -> Result; - fn type_string(&self, gen:&codegen::GeneratorContext, module:Leaf) -> Result; + fn type_string(&self, gen:&codegen::GeneratorContext, module:Leaf) -> Result; } -impl <'a> RustNodeInfo for node::Reader<'a> { - fn parameters_texts(&self, gen:&crate::codegen::GeneratorContext, +impl <'a, A> RustNodeInfo for node::Reader<'a, A> where A: ReaderArena { + fn parameters_texts(&self, gen:&crate::codegen::GeneratorContext, parent_node_id: Option) -> TypeParameterTexts { if self.get_is_generic() { let params = get_type_parameters(&gen, self.get_id(), parent_node_id); @@ -106,10 +107,10 @@ impl <'a> RustNodeInfo for node::Reader<'a> { format!("{}",param) }).collect::>().join(","); let where_clause = "where ".to_string() + &*(params.iter().map(|param| { - format!("{}: for<'c> ::capnp::traits::Owned<'c>", param) + format!("{}: ::capnp::traits::Owned", param) }).collect::>().join(", ") + " "); let where_clause_with_static = "where ".to_string() + &*(params.iter().map(|param| { - format!("{}:'static + for<'c> ::capnp::traits::Owned<'c>", param) + format!("{}:'static + ::capnp::traits::Owned", param) }).collect::>().join(", ") + " "); let pipeline_where_clause = "where ".to_string() + &*(params.iter().map(|param| { format!("{}: ::capnp::traits::Pipelined, <{} as ::capnp::traits::Pipelined>::Pipeline: ::capnp::capability::FromTypelessPipeline", param, param) @@ -145,18 +146,18 @@ impl <'a> RustNodeInfo for node::Reader<'a> { } } -impl <'a> RustTypeInfo for type_::Reader<'a> { +impl <'a, A> RustTypeInfo for type_::Reader<'a, A> where A: ReaderArena { - fn type_string(&self, gen:&codegen::GeneratorContext, module:Leaf) -> Result { + fn type_string(&self, gen:&codegen::GeneratorContext, module:Leaf) -> Result { - let local_lifetime = match module { - Leaf::Reader(lt) => lt, - Leaf::Builder(lt) => lt, - _ => "", + let (local_lifetime, local_arena) = match module { + Leaf::Reader(lt,la) => (lt,la), + Leaf::Builder(lt,la) => (lt,la), + _ => ("",""), }; let lifetime_comma = if local_lifetime == "" { "".to_string() } else { - format!("{},", local_lifetime) + format!("{},{},", local_lifetime, local_arena) }; match self.which()? { @@ -172,8 +173,8 @@ impl <'a> RustTypeInfo for type_::Reader<'a> { type_::Uint64(()) => Ok("u64".to_string()), type_::Float32(()) => Ok("f32".to_string()), type_::Float64(()) => Ok("f64".to_string()), - type_::Text(()) => Ok(format!("::capnp::text::{}", module)), - type_::Data(()) => Ok(format!("::capnp::data::{}", module)), + type_::Text(()) => Ok(format!("::capnp::text::{}<{}>", module.bare_name(), local_lifetime)), + type_::Data(()) => Ok(format!("::capnp::data::{}<{}>", module.bare_name(), local_lifetime)), type_::Struct(st) => { do_branding(gen, st.get_type_id(), st.get_brand()?, module, gen.scope_map[&st.get_type_id()].join("::"), None) @@ -227,15 +228,15 @@ impl <'a> RustTypeInfo for type_::Reader<'a> { let parameter_name = parameter.get_name()?; match module { Leaf::Owned => Ok(parameter_name.to_string()), - Leaf::Reader(lifetime) => { + Leaf::Reader(lifetime, ap) => { Ok(format!( - "<{} as ::capnp::traits::Owned<{}>>::Reader", - parameter_name, lifetime)) + "<{} as ::capnp::traits::Owned>::Reader<{},{}>", + parameter_name, lifetime, ap)) } - Leaf::Builder(lifetime) => { + Leaf::Builder(lifetime, ap) => { Ok(format!( - "<{} as ::capnp::traits::Owned<{}>>::Builder", - parameter_name, lifetime)) + "<{} as ::capnp::traits::Owned>::Builder<{},{}>", + parameter_name, lifetime, ap)) } Leaf::Pipeline => { Ok(format!("<{} as ::capnp::traits::Pipelined>::Pipeline", parameter_name)) @@ -245,11 +246,11 @@ impl <'a> RustTypeInfo for type_::Reader<'a> { }, _ => { match module { - Leaf::Reader(lifetime) => { - Ok(format!("::capnp::any_pointer::Reader<{}>", lifetime)) + Leaf::Reader(lifetime, ap) => { + Ok(format!("::capnp::any_pointer::Reader<{},{}>", lifetime, ap)) } - Leaf::Builder(lifetime) => { - Ok(format!("::capnp::any_pointer::Builder<{}>", lifetime)) + Leaf::Builder(lifetime, ap) => { + Ok(format!("::capnp::any_pointer::Builder<{},{}>", lifetime, ap)) } _ => { Ok(format!("::capnp::any_pointer::{}", module)) @@ -297,9 +298,9 @@ impl <'a> RustTypeInfo for type_::Reader<'a> { /// /// -pub fn do_branding(gen: &GeneratorContext, +pub fn do_branding(gen: &GeneratorContext, node_id: u64, - brand: brand::Reader, + brand: brand::Reader, leaf: Leaf, the_mod: String, mut parent_scope_id: Option) -> Result { @@ -359,8 +360,8 @@ pub fn do_branding(gen: &GeneratorContext, // Now add a lifetime parameter if the leaf has one. match leaf { - Leaf::Reader(lt) => accumulator.push(vec!(lt.to_string())), - Leaf::Builder(lt) => accumulator.push(vec!(lt.to_string())), + Leaf::Reader(lt, ap) => accumulator.push(vec!(lt.to_string(), ap.to_string())), + Leaf::Builder(lt, ap) => accumulator.push(vec!(lt.to_string(), ap.to_string())), Leaf::ServerDispatch => accumulator.push(vec!["_T".to_string()]), // HACK _ => (), } @@ -384,7 +385,7 @@ pub fn do_branding(gen: &GeneratorContext, -pub fn get_type_parameters(gen: &GeneratorContext, +pub fn get_type_parameters(gen: &GeneratorContext, node_id: u64, mut parent_scope_id: Option) -> Vec { let mut current_node_id = node_id; diff --git a/capnpc/src/lib.rs b/capnpc/src/lib.rs index e3ce9b67e..a5e032742 100644 --- a/capnpc/src/lib.rs +++ b/capnpc/src/lib.rs @@ -56,6 +56,9 @@ //! ``` //! +#![allow(incomplete_features)] +#![feature(generic_associated_types)] + /// Code generated from /// [schema.capnp](https://github.com/capnproto/capnproto/blob/master/c%2B%2B/src/capnp/schema.capnp). pub mod schema_capnp; diff --git a/capnpc/src/pointer_constants.rs b/capnpc/src/pointer_constants.rs index afe5d60fc..85f33cfaa 100644 --- a/capnpc/src/pointer_constants.rs +++ b/capnpc/src/pointer_constants.rs @@ -19,6 +19,7 @@ // THE SOFTWARE. use capnp::{any_pointer, message}; +use capnp::private::arena::ReaderArena; use crate::codegen::{FormattedText, GeneratorContext}; use crate::codegen::FormattedText::{Indent, Line, Branch}; @@ -31,7 +32,7 @@ pub struct WordArrayDeclarationOptions { } pub fn word_array_declaration(name: &str, - value: any_pointer::Reader, + value: any_pointer::Reader, options: WordArrayDeclarationOptions) -> ::capnp::Result { let allocator = message::HeapAllocator::new() .first_segment_words(value.target_size()?.word_count as u32 + 1); @@ -57,10 +58,10 @@ pub fn word_array_declaration(name: &str, } pub fn generate_pointer_constant( - gen: &GeneratorContext, + gen: &GeneratorContext, styled_name: &str, - typ: type_::Reader, - value: any_pointer::Reader) + typ: type_::Reader, + value: any_pointer::Reader) -> ::capnp::Result { Ok(Branch(vec![ diff --git a/capnpc/src/schema_capnp.rs b/capnpc/src/schema_capnp.rs index a9cedabf8..06894cc2f 100644 --- a/capnpc/src/schema_capnp.rs +++ b/capnpc/src/schema_capnp.rs @@ -1,4 +1,4 @@ -// Generated by the capnpc-rust plugin to the Cap'n Proto schema compiler. +// @generated by the capnpc-rust plugin to the Cap'n Proto schema compiler. // DO NOT EDIT. // source: schema.capnp @@ -8,43 +8,45 @@ pub mod node { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -57,7 +59,7 @@ pub mod node { } #[inline] pub fn get_display_name(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_display_name(&self) -> bool { !self.reader.get_pointer_field(0).is_null() @@ -71,22 +73,22 @@ pub mod node { self.reader.get_data_field::(2) } #[inline] - pub fn get_nested_nodes(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::node::nested_node::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), None) + pub fn get_nested_nodes(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::nested_node::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(1), ::core::option::Option::None) } pub fn has_nested_nodes(&self) -> bool { !self.reader.get_pointer_field(1).is_null() } #[inline] - pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::annotation::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(2), None) + pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::annotation::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(2), ::core::option::Option::None) } pub fn has_annotations(&self) -> bool { !self.reader.get_pointer_field(2).is_null() } #[inline] - pub fn get_parameters(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::node::parameter::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(5), None) + pub fn get_parameters(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::parameter::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(5), ::core::option::Option::None) } pub fn has_parameters(&self) -> bool { !self.reader.get_pointer_field(5).is_null() @@ -96,90 +98,90 @@ pub mod node { self.reader.get_bool_field(288) } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.reader.get_data_field::(6) { 0 => { - ::std::result::Result::Ok(File( + ::core::result::Result::Ok(File( () )) } 1 => { - ::std::result::Result::Ok(Struct( + ::core::result::Result::Ok(Struct( ::capnp::traits::FromStructReader::new(self.reader) )) } 2 => { - ::std::result::Result::Ok(Enum( + ::core::result::Result::Ok(Enum( ::capnp::traits::FromStructReader::new(self.reader) )) } 3 => { - ::std::result::Result::Ok(Interface( + ::core::result::Result::Ok(Interface( ::capnp::traits::FromStructReader::new(self.reader) )) } 4 => { - ::std::result::Result::Ok(Const( + ::core::result::Result::Ok(Const( ::capnp::traits::FromStructReader::new(self.reader) )) } 5 => { - ::std::result::Result::Ok(Annotation( + ::core::result::Result::Ok(Annotation( ::capnp::traits::FromStructReader::new(self.reader) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_id(self) -> u64 { @@ -191,18 +193,18 @@ pub mod node { } #[inline] pub fn get_display_name(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_display_name(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_display_name(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_display_name(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn get_display_name_prefix_length(self) -> u32 { @@ -221,103 +223,103 @@ pub mod node { self.builder.set_data_field::(2, value); } #[inline] - pub fn get_nested_nodes(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::node::nested_node::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), None) + pub fn get_nested_nodes(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::nested_node::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None) } #[inline] - pub fn set_nested_nodes(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::node::nested_node::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(1), value, false) + pub fn set_nested_nodes(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::nested_node::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false) } #[inline] - pub fn init_nested_nodes(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::node::nested_node::Owned> { + pub fn init_nested_nodes(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::nested_node::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), size) } pub fn has_nested_nodes(&self) -> bool { - !self.builder.get_pointer_field(1).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(1).is_null() } #[inline] - pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::annotation::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), None) + pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::annotation::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), ::core::option::Option::None) } #[inline] - pub fn set_annotations(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::annotation::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(2), value, false) + pub fn set_annotations(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::annotation::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(2), value, false) } #[inline] - pub fn init_annotations(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::annotation::Owned> { + pub fn init_annotations(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::annotation::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(2), size) } pub fn has_annotations(&self) -> bool { - !self.builder.get_pointer_field(2).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(2).is_null() } #[inline] pub fn set_file(&mut self, _value: ()) { self.builder.set_data_field::(6, 0); } #[inline] - pub fn init_struct(self, ) -> crate::schema_capnp::node::struct_::Builder<'a> { - self.builder.set_data_field::(6, 1); - self.builder.set_data_field::(7, 0u16); - self.builder.set_data_field::(12, 0u16); - self.builder.set_data_field::(13, 0u16); - self.builder.set_bool_field(224, false); - self.builder.set_data_field::(15, 0u16); - self.builder.set_data_field::(8, 0u32); - self.builder.get_pointer_field(3).clear(); + pub fn init_struct(mut self, ) -> crate::schema_capnp::node::struct_::Builder<'a, A> { + self.builder.reborrow().set_data_field::(6, 1); + self.builder.reborrow().set_data_field::(7, 0u16); + self.builder.reborrow().set_data_field::(12, 0u16); + self.builder.reborrow().set_data_field::(13, 0u16); + self.builder.reborrow().set_bool_field(224, false); + self.builder.reborrow().set_data_field::(15, 0u16); + self.builder.reborrow().set_data_field::(8, 0u32); + self.builder.reborrow().get_pointer_field(3).clear(); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_enum(self, ) -> crate::schema_capnp::node::enum_::Builder<'a> { - self.builder.set_data_field::(6, 2); - self.builder.get_pointer_field(3).clear(); + pub fn init_enum(mut self, ) -> crate::schema_capnp::node::enum_::Builder<'a, A> { + self.builder.reborrow().set_data_field::(6, 2); + self.builder.reborrow().get_pointer_field(3).clear(); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_interface(self, ) -> crate::schema_capnp::node::interface::Builder<'a> { - self.builder.set_data_field::(6, 3); - self.builder.get_pointer_field(3).clear(); - self.builder.get_pointer_field(4).clear(); + pub fn init_interface(mut self, ) -> crate::schema_capnp::node::interface::Builder<'a, A> { + self.builder.reborrow().set_data_field::(6, 3); + self.builder.reborrow().get_pointer_field(3).clear(); + self.builder.reborrow().get_pointer_field(4).clear(); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_const(self, ) -> crate::schema_capnp::node::const_::Builder<'a> { - self.builder.set_data_field::(6, 4); - self.builder.get_pointer_field(3).clear(); - self.builder.get_pointer_field(4).clear(); + pub fn init_const(mut self, ) -> crate::schema_capnp::node::const_::Builder<'a, A> { + self.builder.reborrow().set_data_field::(6, 4); + self.builder.reborrow().get_pointer_field(3).clear(); + self.builder.reborrow().get_pointer_field(4).clear(); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_annotation(self, ) -> crate::schema_capnp::node::annotation::Builder<'a> { - self.builder.set_data_field::(6, 5); - self.builder.get_pointer_field(3).clear(); - self.builder.set_bool_field(112, false); - self.builder.set_bool_field(113, false); - self.builder.set_bool_field(114, false); - self.builder.set_bool_field(115, false); - self.builder.set_bool_field(116, false); - self.builder.set_bool_field(117, false); - self.builder.set_bool_field(118, false); - self.builder.set_bool_field(119, false); - self.builder.set_bool_field(120, false); - self.builder.set_bool_field(121, false); - self.builder.set_bool_field(122, false); - self.builder.set_bool_field(123, false); + pub fn init_annotation(mut self, ) -> crate::schema_capnp::node::annotation::Builder<'a, A> { + self.builder.reborrow().set_data_field::(6, 5); + self.builder.reborrow().get_pointer_field(3).clear(); + self.builder.reborrow().set_bool_field(112, false); + self.builder.reborrow().set_bool_field(113, false); + self.builder.reborrow().set_bool_field(114, false); + self.builder.reborrow().set_bool_field(115, false); + self.builder.reborrow().set_bool_field(116, false); + self.builder.reborrow().set_bool_field(117, false); + self.builder.reborrow().set_bool_field(118, false); + self.builder.reborrow().set_bool_field(119, false); + self.builder.reborrow().set_bool_field(120, false); + self.builder.reborrow().set_bool_field(121, false); + self.builder.reborrow().set_bool_field(122, false); + self.builder.reborrow().set_bool_field(123, false); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn get_parameters(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::node::parameter::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(5), None) + pub fn get_parameters(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::parameter::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(5), ::core::option::Option::None) } #[inline] - pub fn set_parameters(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::node::parameter::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(5), value, false) + pub fn set_parameters(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::parameter::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(5), value, false) } #[inline] - pub fn init_parameters(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::node::parameter::Owned> { + pub fn init_parameters(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::parameter::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(5), size) } pub fn has_parameters(&self) -> bool { - !self.builder.get_pointer_field(5).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(5).is_null() } #[inline] pub fn get_is_generic(self) -> bool { @@ -328,39 +330,39 @@ pub mod node { self.builder.set_bool_field(288, value); } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.builder.get_data_field::(6) { 0 => { - ::std::result::Result::Ok(File( + ::core::result::Result::Ok(File( () )) } 1 => { - ::std::result::Result::Ok(Struct( + ::core::result::Result::Ok(Struct( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 2 => { - ::std::result::Result::Ok(Enum( + ::core::result::Result::Ok(Enum( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 3 => { - ::std::result::Result::Ok(Interface( + ::core::result::Result::Ok(Interface( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 4 => { - ::std::result::Result::Ok(Const( + ::core::result::Result::Ok(Const( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 5 => { - ::std::result::Result::Ok(Annotation( + ::core::result::Result::Ok(Annotation( ::capnp::traits::FromStructBuilder::new(self.builder) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -386,49 +388,51 @@ pub mod node { Const(A3), Annotation(A4), } - pub type WhichReader<'a,> = Which,crate::schema_capnp::node::enum_::Reader<'a>,crate::schema_capnp::node::interface::Reader<'a>,crate::schema_capnp::node::const_::Reader<'a>,crate::schema_capnp::node::annotation::Reader<'a>>; - pub type WhichBuilder<'a,> = Which,crate::schema_capnp::node::enum_::Builder<'a>,crate::schema_capnp::node::interface::Builder<'a>,crate::schema_capnp::node::const_::Builder<'a>,crate::schema_capnp::node::annotation::Builder<'a>>; + pub type WhichReader<'a,A,> = Which,crate::schema_capnp::node::enum_::Reader<'a, A>,crate::schema_capnp::node::interface::Reader<'a, A>,crate::schema_capnp::node::const_::Reader<'a, A>,crate::schema_capnp::node::annotation::Reader<'a, A>>; + pub type WhichBuilder<'a,A,> = Which,crate::schema_capnp::node::enum_::Builder<'a, A>,crate::schema_capnp::node::interface::Builder<'a, A>,crate::schema_capnp::node::const_::Builder<'a, A>,crate::schema_capnp::node::annotation::Builder<'a, A>>; pub mod parameter { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -437,75 +441,75 @@ pub mod node { } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_name(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_name(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_name(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_name(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } } @@ -527,43 +531,45 @@ pub mod node { pub mod nested_node { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -572,7 +578,7 @@ pub mod node { } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_name(&self) -> bool { !self.reader.get_pointer_field(0).is_null() @@ -583,68 +589,68 @@ pub mod node { } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_name(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_name(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_name(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn get_id(self) -> u64 { @@ -674,43 +680,45 @@ pub mod node { pub mod source_info { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -723,67 +731,67 @@ pub mod node { } #[inline] pub fn get_doc_comment(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_doc_comment(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } #[inline] - pub fn get_members(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::node::source_info::member::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), None) + pub fn get_members(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::source_info::member::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(1), ::core::option::Option::None) } pub fn has_members(&self) -> bool { !self.reader.get_pointer_field(1).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_id(self) -> u64 { @@ -795,33 +803,33 @@ pub mod node { } #[inline] pub fn get_doc_comment(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_doc_comment(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_doc_comment(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_doc_comment(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] - pub fn get_members(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::node::source_info::member::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), None) + pub fn get_members(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::source_info::member::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None) } #[inline] - pub fn set_members(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::node::source_info::member::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(1), value, false) + pub fn set_members(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::source_info::member::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false) } #[inline] - pub fn init_members(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::node::source_info::member::Owned> { + pub fn init_members(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::source_info::member::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), size) } pub fn has_members(&self) -> bool { - !self.builder.get_pointer_field(1).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(1).is_null() } } @@ -842,43 +850,45 @@ pub mod node { pub mod member { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -887,75 +897,75 @@ pub mod node { } #[inline] pub fn get_doc_comment(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_doc_comment(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_doc_comment(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_doc_comment(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_doc_comment(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_doc_comment(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } } @@ -978,43 +988,45 @@ pub mod node { pub mod struct_ { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -1030,7 +1042,7 @@ pub mod node { self.reader.get_data_field::(12) } #[inline] - pub fn get_preferred_list_encoding(self) -> ::std::result::Result { + pub fn get_preferred_list_encoding(self) -> ::core::result::Result { ::capnp::traits::FromU16::from_u16(self.reader.get_data_field::(13)) } #[inline] @@ -1046,61 +1058,61 @@ pub mod node { self.reader.get_data_field::(8) } #[inline] - pub fn get_fields(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::field::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(3), None) + pub fn get_fields(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::field::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(3), ::core::option::Option::None) } pub fn has_fields(&self) -> bool { !self.reader.get_pointer_field(3).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_data_word_count(self) -> u16 { @@ -1119,7 +1131,7 @@ pub mod node { self.builder.set_data_field::(12, value); } #[inline] - pub fn get_preferred_list_encoding(self) -> ::std::result::Result { + pub fn get_preferred_list_encoding(self) -> ::core::result::Result { ::capnp::traits::FromU16::from_u16(self.builder.get_data_field::(13)) } #[inline] @@ -1151,19 +1163,19 @@ pub mod node { self.builder.set_data_field::(8, value); } #[inline] - pub fn get_fields(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::field::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), None) + pub fn get_fields(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::field::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), ::core::option::Option::None) } #[inline] - pub fn set_fields(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::field::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(3), value, false) + pub fn set_fields(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::field::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(3), value, false) } #[inline] - pub fn init_fields(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::field::Owned> { + pub fn init_fields(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::field::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(3), size) } pub fn has_fields(&self) -> bool { - !self.builder.get_pointer_field(3).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(3).is_null() } } @@ -1185,43 +1197,45 @@ pub mod node { pub mod enum_ { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -1229,76 +1243,76 @@ pub mod node { self.reader.total_size() } #[inline] - pub fn get_enumerants(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::enumerant::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(3), None) + pub fn get_enumerants(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::enumerant::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(3), ::core::option::Option::None) } pub fn has_enumerants(&self) -> bool { !self.reader.get_pointer_field(3).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] - pub fn get_enumerants(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::enumerant::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), None) + pub fn get_enumerants(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::enumerant::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), ::core::option::Option::None) } #[inline] - pub fn set_enumerants(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::enumerant::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(3), value, false) + pub fn set_enumerants(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::enumerant::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(3), value, false) } #[inline] - pub fn init_enumerants(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::enumerant::Owned> { + pub fn init_enumerants(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::enumerant::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(3), size) } pub fn has_enumerants(&self) -> bool { - !self.builder.get_pointer_field(3).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(3).is_null() } } @@ -1320,43 +1334,45 @@ pub mod node { pub mod interface { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -1364,98 +1380,98 @@ pub mod node { self.reader.total_size() } #[inline] - pub fn get_methods(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::method::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(3), None) + pub fn get_methods(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::method::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(3), ::core::option::Option::None) } pub fn has_methods(&self) -> bool { !self.reader.get_pointer_field(3).is_null() } #[inline] - pub fn get_superclasses(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::superclass::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(4), None) + pub fn get_superclasses(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::superclass::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(4), ::core::option::Option::None) } pub fn has_superclasses(&self) -> bool { !self.reader.get_pointer_field(4).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] - pub fn get_methods(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::method::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), None) + pub fn get_methods(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::method::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), ::core::option::Option::None) } #[inline] - pub fn set_methods(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::method::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(3), value, false) + pub fn set_methods(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::method::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(3), value, false) } #[inline] - pub fn init_methods(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::method::Owned> { + pub fn init_methods(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::method::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(3), size) } pub fn has_methods(&self) -> bool { - !self.builder.get_pointer_field(3).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(3).is_null() } #[inline] - pub fn get_superclasses(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::superclass::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(4), None) + pub fn get_superclasses(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::superclass::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(4), ::core::option::Option::None) } #[inline] - pub fn set_superclasses(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::superclass::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(4), value, false) + pub fn set_superclasses(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::superclass::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(4), value, false) } #[inline] - pub fn init_superclasses(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::superclass::Owned> { + pub fn init_superclasses(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::superclass::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(4), size) } pub fn has_superclasses(&self) -> bool { - !self.builder.get_pointer_field(4).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(4).is_null() } } @@ -1477,43 +1493,45 @@ pub mod node { pub mod const_ { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -1521,98 +1539,98 @@ pub mod node { self.reader.total_size() } #[inline] - pub fn get_type(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(3), None) + pub fn get_type(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(3), ::core::option::Option::None) } pub fn has_type(&self) -> bool { !self.reader.get_pointer_field(3).is_null() } #[inline] - pub fn get_value(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(4), None) + pub fn get_value(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(4), ::core::option::Option::None) } pub fn has_value(&self) -> bool { !self.reader.get_pointer_field(4).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] - pub fn get_type(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), None) + pub fn get_type(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), ::core::option::Option::None) } #[inline] - pub fn set_type<'b>(&mut self, value: crate::schema_capnp::type_::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(3), value, false) + pub fn set_type<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::type_::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(3), value, false) } #[inline] - pub fn init_type(self, ) -> crate::schema_capnp::type_::Builder<'a> { + pub fn init_type(self, ) -> crate::schema_capnp::type_::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(3), 0) } pub fn has_type(&self) -> bool { - !self.builder.get_pointer_field(3).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(3).is_null() } #[inline] - pub fn get_value(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(4), None) + pub fn get_value(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(4), ::core::option::Option::None) } #[inline] - pub fn set_value<'b>(&mut self, value: crate::schema_capnp::value::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(4), value, false) + pub fn set_value<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::value::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(4), value, false) } #[inline] - pub fn init_value(self, ) -> crate::schema_capnp::value::Builder<'a> { + pub fn init_value(self, ) -> crate::schema_capnp::value::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(4), 0) } pub fn has_value(&self) -> bool { - !self.builder.get_pointer_field(4).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(4).is_null() } } @@ -1640,43 +1658,45 @@ pub mod node { pub mod annotation { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -1684,8 +1704,8 @@ pub mod node { self.reader.total_size() } #[inline] - pub fn get_type(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(3), None) + pub fn get_type(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(3), ::core::option::Option::None) } pub fn has_type(&self) -> bool { !self.reader.get_pointer_field(3).is_null() @@ -1740,68 +1760,68 @@ pub mod node { } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] - pub fn get_type(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), None) + pub fn get_type(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), ::core::option::Option::None) } #[inline] - pub fn set_type<'b>(&mut self, value: crate::schema_capnp::type_::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(3), value, false) + pub fn set_type<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::type_::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(3), value, false) } #[inline] - pub fn init_type(self, ) -> crate::schema_capnp::type_::Builder<'a> { + pub fn init_type(self, ) -> crate::schema_capnp::type_::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(3), 0) } pub fn has_type(&self) -> bool { - !self.builder.get_pointer_field(3).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(3).is_null() } #[inline] pub fn get_targets_file(self) -> bool { @@ -1925,43 +1945,45 @@ pub mod field { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -1970,7 +1992,7 @@ pub mod field { } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_name(&self) -> bool { !self.reader.get_pointer_field(0).is_null() @@ -1980,8 +2002,8 @@ pub mod field { self.reader.get_data_field::(0) } #[inline] - pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::annotation::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), None) + pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::annotation::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(1), ::core::option::Option::None) } pub fn has_annotations(&self) -> bool { !self.reader.get_pointer_field(1).is_null() @@ -1991,89 +2013,89 @@ pub mod field { self.reader.get_data_field_mask::(1, 65535) } #[inline] - pub fn get_ordinal(self) -> crate::schema_capnp::field::ordinal::Reader<'a> { + pub fn get_ordinal(self) -> crate::schema_capnp::field::ordinal::Reader<'a, A> { ::capnp::traits::FromStructReader::new(self.reader) } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.reader.get_data_field::(4) { 0 => { - ::std::result::Result::Ok(Slot( + ::core::result::Result::Ok(Slot( ::capnp::traits::FromStructReader::new(self.reader) )) } 1 => { - ::std::result::Result::Ok(Group( + ::core::result::Result::Ok(Group( ::capnp::traits::FromStructReader::new(self.reader) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_name(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_name(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_name(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn get_code_order(self) -> u16 { @@ -2084,19 +2106,19 @@ pub mod field { self.builder.set_data_field::(0, value); } #[inline] - pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::annotation::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), None) + pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::annotation::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None) } #[inline] - pub fn set_annotations(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::annotation::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(1), value, false) + pub fn set_annotations(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::annotation::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false) } #[inline] - pub fn init_annotations(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::annotation::Owned> { + pub fn init_annotations(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::annotation::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), size) } pub fn has_annotations(&self) -> bool { - !self.builder.get_pointer_field(1).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(1).is_null() } #[inline] pub fn get_discriminant_value(self) -> u16 { @@ -2107,44 +2129,44 @@ pub mod field { self.builder.set_data_field_mask::(1, value, 65535); } #[inline] - pub fn init_slot(self, ) -> crate::schema_capnp::field::slot::Builder<'a> { - self.builder.set_data_field::(4, 0); - self.builder.set_data_field::(1, 0u32); - self.builder.get_pointer_field(2).clear(); - self.builder.get_pointer_field(3).clear(); - self.builder.set_bool_field(128, false); + pub fn init_slot(mut self, ) -> crate::schema_capnp::field::slot::Builder<'a, A> { + self.builder.reborrow().set_data_field::(4, 0); + self.builder.reborrow().set_data_field::(1, 0u32); + self.builder.reborrow().get_pointer_field(2).clear(); + self.builder.reborrow().get_pointer_field(3).clear(); + self.builder.reborrow().set_bool_field(128, false); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_group(self, ) -> crate::schema_capnp::field::group::Builder<'a> { + pub fn init_group(self, ) -> crate::schema_capnp::field::group::Builder<'a, A> { self.builder.set_data_field::(4, 1); self.builder.set_data_field::(2, 0u64); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn get_ordinal(self) -> crate::schema_capnp::field::ordinal::Builder<'a> { + pub fn get_ordinal(self) -> crate::schema_capnp::field::ordinal::Builder<'a, A> { ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_ordinal(self, ) -> crate::schema_capnp::field::ordinal::Builder<'a> { - self.builder.set_data_field::(5, 0); - self.builder.set_data_field::(6, 0u16); + pub fn init_ordinal(mut self, ) -> crate::schema_capnp::field::ordinal::Builder<'a, A> { + self.builder.reborrow().set_data_field::(5, 0); + self.builder.reborrow().set_data_field::(6, 0u16); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.builder.get_data_field::(4) { 0 => { - ::std::result::Result::Ok(Slot( + ::core::result::Result::Ok(Slot( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 1 => { - ::std::result::Result::Ok(Group( + ::core::result::Result::Ok(Group( ::capnp::traits::FromStructBuilder::new(self.builder) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -2169,50 +2191,52 @@ pub mod field { Slot(A0), Group(A1), } - pub type WhichReader<'a,> = Which,crate::schema_capnp::field::group::Reader<'a>>; - pub type WhichBuilder<'a,> = Which,crate::schema_capnp::field::group::Builder<'a>>; + pub type WhichReader<'a,A,> = Which,crate::schema_capnp::field::group::Reader<'a, A>>; + pub type WhichBuilder<'a,A,> = Which,crate::schema_capnp::field::group::Builder<'a, A>>; pub const NO_DISCRIMINANT: u16 = 65535; pub mod slot { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -2224,15 +2248,15 @@ pub mod field { self.reader.get_data_field::(1) } #[inline] - pub fn get_type(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(2), None) + pub fn get_type(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(2), ::core::option::Option::None) } pub fn has_type(&self) -> bool { !self.reader.get_pointer_field(2).is_null() } #[inline] - pub fn get_default_value(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(3), None) + pub fn get_default_value(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(3), ::core::option::Option::None) } pub fn has_default_value(&self) -> bool { !self.reader.get_pointer_field(3).is_null() @@ -2243,53 +2267,53 @@ pub mod field { } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_offset(self) -> u32 { @@ -2300,34 +2324,34 @@ pub mod field { self.builder.set_data_field::(1, value); } #[inline] - pub fn get_type(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), None) + pub fn get_type(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), ::core::option::Option::None) } #[inline] - pub fn set_type<'b>(&mut self, value: crate::schema_capnp::type_::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(2), value, false) + pub fn set_type<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::type_::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(2), value, false) } #[inline] - pub fn init_type(self, ) -> crate::schema_capnp::type_::Builder<'a> { + pub fn init_type(self, ) -> crate::schema_capnp::type_::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(2), 0) } pub fn has_type(&self) -> bool { - !self.builder.get_pointer_field(2).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(2).is_null() } #[inline] - pub fn get_default_value(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), None) + pub fn get_default_value(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), ::core::option::Option::None) } #[inline] - pub fn set_default_value<'b>(&mut self, value: crate::schema_capnp::value::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(3), value, false) + pub fn set_default_value<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::value::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(3), value, false) } #[inline] - pub fn init_default_value(self, ) -> crate::schema_capnp::value::Builder<'a> { + pub fn init_default_value(self, ) -> crate::schema_capnp::value::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(3), 0) } pub fn has_default_value(&self) -> bool { - !self.builder.get_pointer_field(3).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(3).is_null() } #[inline] pub fn get_had_explicit_default(self) -> bool { @@ -2363,43 +2387,45 @@ pub mod field { pub mod group { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -2412,53 +2438,53 @@ pub mod field { } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_type_id(self) -> u64 { @@ -2490,43 +2516,45 @@ pub mod field { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -2534,70 +2562,70 @@ pub mod field { self.reader.total_size() } #[inline] - pub fn which(self) -> ::std::result::Result { + pub fn which(self) -> ::core::result::Result { match self.reader.get_data_field::(5) { 0 => { - ::std::result::Result::Ok(Implicit( + ::core::result::Result::Ok(Implicit( () )) } 1 => { - ::std::result::Result::Ok(Explicit( + ::core::result::Result::Ok(Explicit( self.reader.get_data_field::(6) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn set_implicit(&mut self, _value: ()) { @@ -2609,19 +2637,19 @@ pub mod field { self.builder.set_data_field::(6, value); } #[inline] - pub fn which(self) -> ::std::result::Result { + pub fn which(self) -> ::core::result::Result { match self.builder.get_data_field::(5) { 0 => { - ::std::result::Result::Ok(Implicit( + ::core::result::Result::Ok(Implicit( () )) } 1 => { - ::std::result::Result::Ok(Explicit( + ::core::result::Result::Ok(Explicit( self.builder.get_data_field::(6) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -2651,43 +2679,45 @@ pub mod field { pub mod enumerant { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -2696,7 +2726,7 @@ pub mod enumerant { } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_name(&self) -> bool { !self.reader.get_pointer_field(0).is_null() @@ -2706,76 +2736,76 @@ pub mod enumerant { self.reader.get_data_field::(0) } #[inline] - pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::annotation::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), None) + pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::annotation::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(1), ::core::option::Option::None) } pub fn has_annotations(&self) -> bool { !self.reader.get_pointer_field(1).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_name(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_name(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_name(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn get_code_order(self) -> u16 { @@ -2786,19 +2816,19 @@ pub mod enumerant { self.builder.set_data_field::(0, value); } #[inline] - pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::annotation::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), None) + pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::annotation::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None) } #[inline] - pub fn set_annotations(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::annotation::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(1), value, false) + pub fn set_annotations(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::annotation::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false) } #[inline] - pub fn init_annotations(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::annotation::Owned> { + pub fn init_annotations(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::annotation::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), size) } pub fn has_annotations(&self) -> bool { - !self.builder.get_pointer_field(1).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(1).is_null() } } @@ -2820,43 +2850,45 @@ pub mod enumerant { pub mod superclass { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -2868,61 +2900,61 @@ pub mod superclass { self.reader.get_data_field::(0) } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_brand(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_id(self) -> u64 { @@ -2933,19 +2965,19 @@ pub mod superclass { self.builder.set_data_field::(0, value); } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] - pub fn set_brand<'b>(&mut self, value: crate::schema_capnp::brand::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + pub fn set_brand<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::brand::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a> { + pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0) } pub fn has_brand(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } } @@ -2970,43 +3002,45 @@ pub mod superclass { pub mod method { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -3015,7 +3049,7 @@ pub mod method { } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_name(&self) -> bool { !self.reader.get_pointer_field(0).is_null() @@ -3033,97 +3067,97 @@ pub mod method { self.reader.get_data_field::(2) } #[inline] - pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::annotation::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), None) + pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::annotation::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(1), ::core::option::Option::None) } pub fn has_annotations(&self) -> bool { !self.reader.get_pointer_field(1).is_null() } #[inline] - pub fn get_param_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(2), None) + pub fn get_param_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(2), ::core::option::Option::None) } pub fn has_param_brand(&self) -> bool { !self.reader.get_pointer_field(2).is_null() } #[inline] - pub fn get_result_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(3), None) + pub fn get_result_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(3), ::core::option::Option::None) } pub fn has_result_brand(&self) -> bool { !self.reader.get_pointer_field(3).is_null() } #[inline] - pub fn get_implicit_parameters(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::node::parameter::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(4), None) + pub fn get_implicit_parameters(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::parameter::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(4), ::core::option::Option::None) } pub fn has_implicit_parameters(&self) -> bool { !self.reader.get_pointer_field(4).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_name(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_name(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_name(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn get_code_order(self) -> u16 { @@ -3150,64 +3184,64 @@ pub mod method { self.builder.set_data_field::(2, value); } #[inline] - pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::annotation::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), None) + pub fn get_annotations(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::annotation::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None) } #[inline] - pub fn set_annotations(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::annotation::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(1), value, false) + pub fn set_annotations(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::annotation::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false) } #[inline] - pub fn init_annotations(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::annotation::Owned> { + pub fn init_annotations(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::annotation::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), size) } pub fn has_annotations(&self) -> bool { - !self.builder.get_pointer_field(1).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(1).is_null() } #[inline] - pub fn get_param_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), None) + pub fn get_param_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), ::core::option::Option::None) } #[inline] - pub fn set_param_brand<'b>(&mut self, value: crate::schema_capnp::brand::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(2), value, false) + pub fn set_param_brand<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::brand::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(2), value, false) } #[inline] - pub fn init_param_brand(self, ) -> crate::schema_capnp::brand::Builder<'a> { + pub fn init_param_brand(self, ) -> crate::schema_capnp::brand::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(2), 0) } pub fn has_param_brand(&self) -> bool { - !self.builder.get_pointer_field(2).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(2).is_null() } #[inline] - pub fn get_result_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), None) + pub fn get_result_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), ::core::option::Option::None) } #[inline] - pub fn set_result_brand<'b>(&mut self, value: crate::schema_capnp::brand::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(3), value, false) + pub fn set_result_brand<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::brand::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(3), value, false) } #[inline] - pub fn init_result_brand(self, ) -> crate::schema_capnp::brand::Builder<'a> { + pub fn init_result_brand(self, ) -> crate::schema_capnp::brand::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(3), 0) } pub fn has_result_brand(&self) -> bool { - !self.builder.get_pointer_field(3).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(3).is_null() } #[inline] - pub fn get_implicit_parameters(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::node::parameter::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(4), None) + pub fn get_implicit_parameters(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::parameter::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(4), ::core::option::Option::None) } #[inline] - pub fn set_implicit_parameters(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::node::parameter::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(4), value, false) + pub fn set_implicit_parameters(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::parameter::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(4), value, false) } #[inline] - pub fn init_implicit_parameters(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::node::parameter::Owned> { + pub fn init_implicit_parameters(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::parameter::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(4), size) } pub fn has_implicit_parameters(&self) -> bool { - !self.builder.get_pointer_field(4).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(4).is_null() } } @@ -3237,43 +3271,45 @@ pub mod type_ { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -3281,155 +3317,155 @@ pub mod type_ { self.reader.total_size() } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.reader.get_data_field::(0) { 0 => { - ::std::result::Result::Ok(Void( + ::core::result::Result::Ok(Void( () )) } 1 => { - ::std::result::Result::Ok(Bool( + ::core::result::Result::Ok(Bool( () )) } 2 => { - ::std::result::Result::Ok(Int8( + ::core::result::Result::Ok(Int8( () )) } 3 => { - ::std::result::Result::Ok(Int16( + ::core::result::Result::Ok(Int16( () )) } 4 => { - ::std::result::Result::Ok(Int32( + ::core::result::Result::Ok(Int32( () )) } 5 => { - ::std::result::Result::Ok(Int64( + ::core::result::Result::Ok(Int64( () )) } 6 => { - ::std::result::Result::Ok(Uint8( + ::core::result::Result::Ok(Uint8( () )) } 7 => { - ::std::result::Result::Ok(Uint16( + ::core::result::Result::Ok(Uint16( () )) } 8 => { - ::std::result::Result::Ok(Uint32( + ::core::result::Result::Ok(Uint32( () )) } 9 => { - ::std::result::Result::Ok(Uint64( + ::core::result::Result::Ok(Uint64( () )) } 10 => { - ::std::result::Result::Ok(Float32( + ::core::result::Result::Ok(Float32( () )) } 11 => { - ::std::result::Result::Ok(Float64( + ::core::result::Result::Ok(Float64( () )) } 12 => { - ::std::result::Result::Ok(Text( + ::core::result::Result::Ok(Text( () )) } 13 => { - ::std::result::Result::Ok(Data( + ::core::result::Result::Ok(Data( () )) } 14 => { - ::std::result::Result::Ok(List( + ::core::result::Result::Ok(List( ::capnp::traits::FromStructReader::new(self.reader) )) } 15 => { - ::std::result::Result::Ok(Enum( + ::core::result::Result::Ok(Enum( ::capnp::traits::FromStructReader::new(self.reader) )) } 16 => { - ::std::result::Result::Ok(Struct( + ::core::result::Result::Ok(Struct( ::capnp::traits::FromStructReader::new(self.reader) )) } 17 => { - ::std::result::Result::Ok(Interface( + ::core::result::Result::Ok(Interface( ::capnp::traits::FromStructReader::new(self.reader) )) } 18 => { - ::std::result::Result::Ok(AnyPointer( + ::core::result::Result::Ok(AnyPointer( ::capnp::traits::FromStructReader::new(self.reader) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn set_void(&mut self, _value: ()) { @@ -3488,141 +3524,141 @@ pub mod type_ { self.builder.set_data_field::(0, 13); } #[inline] - pub fn init_list(self, ) -> crate::schema_capnp::type_::list::Builder<'a> { - self.builder.set_data_field::(0, 14); - self.builder.get_pointer_field(0).clear(); + pub fn init_list(mut self, ) -> crate::schema_capnp::type_::list::Builder<'a, A> { + self.builder.reborrow().set_data_field::(0, 14); + self.builder.reborrow().get_pointer_field(0).clear(); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_enum(self, ) -> crate::schema_capnp::type_::enum_::Builder<'a> { - self.builder.set_data_field::(0, 15); - self.builder.set_data_field::(1, 0u64); - self.builder.get_pointer_field(0).clear(); + pub fn init_enum(mut self, ) -> crate::schema_capnp::type_::enum_::Builder<'a, A> { + self.builder.reborrow().set_data_field::(0, 15); + self.builder.reborrow().set_data_field::(1, 0u64); + self.builder.reborrow().get_pointer_field(0).clear(); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_struct(self, ) -> crate::schema_capnp::type_::struct_::Builder<'a> { - self.builder.set_data_field::(0, 16); - self.builder.set_data_field::(1, 0u64); - self.builder.get_pointer_field(0).clear(); + pub fn init_struct(mut self, ) -> crate::schema_capnp::type_::struct_::Builder<'a, A> { + self.builder.reborrow().set_data_field::(0, 16); + self.builder.reborrow().set_data_field::(1, 0u64); + self.builder.reborrow().get_pointer_field(0).clear(); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_interface(self, ) -> crate::schema_capnp::type_::interface::Builder<'a> { - self.builder.set_data_field::(0, 17); - self.builder.set_data_field::(1, 0u64); - self.builder.get_pointer_field(0).clear(); + pub fn init_interface(mut self, ) -> crate::schema_capnp::type_::interface::Builder<'a, A> { + self.builder.reborrow().set_data_field::(0, 17); + self.builder.reborrow().set_data_field::(1, 0u64); + self.builder.reborrow().get_pointer_field(0).clear(); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_any_pointer(self, ) -> crate::schema_capnp::type_::any_pointer::Builder<'a> { + pub fn init_any_pointer(mut self, ) -> crate::schema_capnp::type_::any_pointer::Builder<'a, A> { self.builder.set_data_field::(0, 18); - self.builder.set_data_field::(4, 0); - self.builder.set_data_field::(5, 0); + self.builder.reborrow().set_data_field::(4, 0); + self.builder.reborrow().set_data_field::(5, 0); self.builder.set_data_field::(2, 0u64); self.builder.set_data_field::(5, 0u16); self.builder.set_data_field::(5, 0u16); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.builder.get_data_field::(0) { 0 => { - ::std::result::Result::Ok(Void( + ::core::result::Result::Ok(Void( () )) } 1 => { - ::std::result::Result::Ok(Bool( + ::core::result::Result::Ok(Bool( () )) } 2 => { - ::std::result::Result::Ok(Int8( + ::core::result::Result::Ok(Int8( () )) } 3 => { - ::std::result::Result::Ok(Int16( + ::core::result::Result::Ok(Int16( () )) } 4 => { - ::std::result::Result::Ok(Int32( + ::core::result::Result::Ok(Int32( () )) } 5 => { - ::std::result::Result::Ok(Int64( + ::core::result::Result::Ok(Int64( () )) } 6 => { - ::std::result::Result::Ok(Uint8( + ::core::result::Result::Ok(Uint8( () )) } 7 => { - ::std::result::Result::Ok(Uint16( + ::core::result::Result::Ok(Uint16( () )) } 8 => { - ::std::result::Result::Ok(Uint32( + ::core::result::Result::Ok(Uint32( () )) } 9 => { - ::std::result::Result::Ok(Uint64( + ::core::result::Result::Ok(Uint64( () )) } 10 => { - ::std::result::Result::Ok(Float32( + ::core::result::Result::Ok(Float32( () )) } 11 => { - ::std::result::Result::Ok(Float64( + ::core::result::Result::Ok(Float64( () )) } 12 => { - ::std::result::Result::Ok(Text( + ::core::result::Result::Ok(Text( () )) } 13 => { - ::std::result::Result::Ok(Data( + ::core::result::Result::Ok(Data( () )) } 14 => { - ::std::result::Result::Ok(List( + ::core::result::Result::Ok(List( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 15 => { - ::std::result::Result::Ok(Enum( + ::core::result::Result::Ok(Enum( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 16 => { - ::std::result::Result::Ok(Struct( + ::core::result::Result::Ok(Struct( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 17 => { - ::std::result::Result::Ok(Interface( + ::core::result::Result::Ok(Interface( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 18 => { - ::std::result::Result::Ok(AnyPointer( + ::core::result::Result::Ok(AnyPointer( ::capnp::traits::FromStructBuilder::new(self.builder) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -3661,49 +3697,51 @@ pub mod type_ { Interface(A3), AnyPointer(A4), } - pub type WhichReader<'a,> = Which,crate::schema_capnp::type_::enum_::Reader<'a>,crate::schema_capnp::type_::struct_::Reader<'a>,crate::schema_capnp::type_::interface::Reader<'a>,crate::schema_capnp::type_::any_pointer::Reader<'a>>; - pub type WhichBuilder<'a,> = Which,crate::schema_capnp::type_::enum_::Builder<'a>,crate::schema_capnp::type_::struct_::Builder<'a>,crate::schema_capnp::type_::interface::Builder<'a>,crate::schema_capnp::type_::any_pointer::Builder<'a>>; + pub type WhichReader<'a,A,> = Which,crate::schema_capnp::type_::enum_::Reader<'a, A>,crate::schema_capnp::type_::struct_::Reader<'a, A>,crate::schema_capnp::type_::interface::Reader<'a, A>,crate::schema_capnp::type_::any_pointer::Reader<'a, A>>; + pub type WhichBuilder<'a,A,> = Which,crate::schema_capnp::type_::enum_::Builder<'a, A>,crate::schema_capnp::type_::struct_::Builder<'a, A>,crate::schema_capnp::type_::interface::Builder<'a, A>,crate::schema_capnp::type_::any_pointer::Builder<'a, A>>; pub mod list { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -3711,76 +3749,76 @@ pub mod type_ { self.reader.total_size() } #[inline] - pub fn get_element_type(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + pub fn get_element_type(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_element_type(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] - pub fn get_element_type(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + pub fn get_element_type(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] - pub fn set_element_type<'b>(&mut self, value: crate::schema_capnp::type_::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + pub fn set_element_type<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::type_::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_element_type(self, ) -> crate::schema_capnp::type_::Builder<'a> { + pub fn init_element_type(self, ) -> crate::schema_capnp::type_::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0) } pub fn has_element_type(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } } @@ -3805,43 +3843,45 @@ pub mod type_ { pub mod enum_ { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -3853,61 +3893,61 @@ pub mod type_ { self.reader.get_data_field::(1) } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_brand(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_type_id(self) -> u64 { @@ -3918,19 +3958,19 @@ pub mod type_ { self.builder.set_data_field::(1, value); } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] - pub fn set_brand<'b>(&mut self, value: crate::schema_capnp::brand::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + pub fn set_brand<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::brand::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a> { + pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0) } pub fn has_brand(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } } @@ -3955,43 +3995,45 @@ pub mod type_ { pub mod struct_ { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -4003,61 +4045,61 @@ pub mod type_ { self.reader.get_data_field::(1) } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_brand(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_type_id(self) -> u64 { @@ -4068,19 +4110,19 @@ pub mod type_ { self.builder.set_data_field::(1, value); } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] - pub fn set_brand<'b>(&mut self, value: crate::schema_capnp::brand::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + pub fn set_brand<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::brand::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a> { + pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0) } pub fn has_brand(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } } @@ -4105,43 +4147,45 @@ pub mod type_ { pub mod interface { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -4153,61 +4197,61 @@ pub mod type_ { self.reader.get_data_field::(1) } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_brand(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_type_id(self) -> u64 { @@ -4218,19 +4262,19 @@ pub mod type_ { self.builder.set_data_field::(1, value); } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] - pub fn set_brand<'b>(&mut self, value: crate::schema_capnp::brand::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + pub fn set_brand<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::brand::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a> { + pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0) } pub fn has_brand(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } } @@ -4257,43 +4301,45 @@ pub mod type_ { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -4301,114 +4347,114 @@ pub mod type_ { self.reader.total_size() } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.reader.get_data_field::(4) { 0 => { - ::std::result::Result::Ok(Unconstrained( + ::core::result::Result::Ok(Unconstrained( ::capnp::traits::FromStructReader::new(self.reader) )) } 1 => { - ::std::result::Result::Ok(Parameter( + ::core::result::Result::Ok(Parameter( ::capnp::traits::FromStructReader::new(self.reader) )) } 2 => { - ::std::result::Result::Ok(ImplicitMethodParameter( + ::core::result::Result::Ok(ImplicitMethodParameter( ::capnp::traits::FromStructReader::new(self.reader) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] - pub fn init_unconstrained(self, ) -> crate::schema_capnp::type_::any_pointer::unconstrained::Builder<'a> { - self.builder.set_data_field::(4, 0); - self.builder.set_data_field::(5, 0); + pub fn init_unconstrained(mut self, ) -> crate::schema_capnp::type_::any_pointer::unconstrained::Builder<'a, A> { + self.builder.reborrow().set_data_field::(4, 0); + self.builder.reborrow().set_data_field::(5, 0); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_parameter(self, ) -> crate::schema_capnp::type_::any_pointer::parameter::Builder<'a> { - self.builder.set_data_field::(4, 1); - self.builder.set_data_field::(2, 0u64); - self.builder.set_data_field::(5, 0u16); + pub fn init_parameter(mut self, ) -> crate::schema_capnp::type_::any_pointer::parameter::Builder<'a, A> { + self.builder.reborrow().set_data_field::(4, 1); + self.builder.reborrow().set_data_field::(2, 0u64); + self.builder.reborrow().set_data_field::(5, 0u16); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn init_implicit_method_parameter(self, ) -> crate::schema_capnp::type_::any_pointer::implicit_method_parameter::Builder<'a> { + pub fn init_implicit_method_parameter(self, ) -> crate::schema_capnp::type_::any_pointer::implicit_method_parameter::Builder<'a, A> { self.builder.set_data_field::(4, 2); self.builder.set_data_field::(5, 0u16); ::capnp::traits::FromStructBuilder::new(self.builder) } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.builder.get_data_field::(4) { 0 => { - ::std::result::Result::Ok(Unconstrained( + ::core::result::Result::Ok(Unconstrained( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 1 => { - ::std::result::Result::Ok(Parameter( + ::core::result::Result::Ok(Parameter( ::capnp::traits::FromStructBuilder::new(self.builder) )) } 2 => { - ::std::result::Result::Ok(ImplicitMethodParameter( + ::core::result::Result::Ok(ImplicitMethodParameter( ::capnp::traits::FromStructBuilder::new(self.builder) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -4431,51 +4477,53 @@ pub mod type_ { Parameter(A1), ImplicitMethodParameter(A2), } - pub type WhichReader<'a,> = Which,crate::schema_capnp::type_::any_pointer::parameter::Reader<'a>,crate::schema_capnp::type_::any_pointer::implicit_method_parameter::Reader<'a>>; - pub type WhichBuilder<'a,> = Which,crate::schema_capnp::type_::any_pointer::parameter::Builder<'a>,crate::schema_capnp::type_::any_pointer::implicit_method_parameter::Builder<'a>>; + pub type WhichReader<'a,A,> = Which,crate::schema_capnp::type_::any_pointer::parameter::Reader<'a, A>,crate::schema_capnp::type_::any_pointer::implicit_method_parameter::Reader<'a, A>>; + pub type WhichBuilder<'a,A,> = Which,crate::schema_capnp::type_::any_pointer::parameter::Builder<'a, A>,crate::schema_capnp::type_::any_pointer::implicit_method_parameter::Builder<'a, A>>; pub mod unconstrained { pub use self::Which::{AnyKind,Struct,List,Capability}; #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -4483,80 +4531,80 @@ pub mod type_ { self.reader.total_size() } #[inline] - pub fn which(self) -> ::std::result::Result { + pub fn which(self) -> ::core::result::Result { match self.reader.get_data_field::(5) { 0 => { - ::std::result::Result::Ok(AnyKind( + ::core::result::Result::Ok(AnyKind( () )) } 1 => { - ::std::result::Result::Ok(Struct( + ::core::result::Result::Ok(Struct( () )) } 2 => { - ::std::result::Result::Ok(List( + ::core::result::Result::Ok(List( () )) } 3 => { - ::std::result::Result::Ok(Capability( + ::core::result::Result::Ok(Capability( () )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn set_any_kind(&mut self, _value: ()) { @@ -4575,29 +4623,29 @@ pub mod type_ { self.builder.set_data_field::(5, 3); } #[inline] - pub fn which(self) -> ::std::result::Result { + pub fn which(self) -> ::core::result::Result { match self.builder.get_data_field::(5) { 0 => { - ::std::result::Result::Ok(AnyKind( + ::core::result::Result::Ok(AnyKind( () )) } 1 => { - ::std::result::Result::Ok(Struct( + ::core::result::Result::Ok(Struct( () )) } 2 => { - ::std::result::Result::Ok(List( + ::core::result::Result::Ok(List( () )) } 3 => { - ::std::result::Result::Ok(Capability( + ::core::result::Result::Ok(Capability( () )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -4628,43 +4676,45 @@ pub mod type_ { pub mod parameter { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -4681,53 +4731,53 @@ pub mod type_ { } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_scope_id(self) -> u64 { @@ -4765,43 +4815,45 @@ pub mod type_ { pub mod implicit_method_parameter { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -4814,53 +4866,53 @@ pub mod type_ { } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_parameter_index(self) -> u16 { @@ -4892,43 +4944,45 @@ pub mod type_ { pub mod brand { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -4936,76 +4990,76 @@ pub mod brand { self.reader.total_size() } #[inline] - pub fn get_scopes(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::brand::scope::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + pub fn get_scopes(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::brand::scope::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_scopes(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] - pub fn get_scopes(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::brand::scope::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + pub fn get_scopes(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::brand::scope::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] - pub fn set_scopes(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::brand::scope::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + pub fn set_scopes(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::brand::scope::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_scopes(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::brand::scope::Owned> { + pub fn init_scopes(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::brand::scope::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), size) } pub fn has_scopes(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } } @@ -5028,43 +5082,45 @@ pub mod brand { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -5080,70 +5136,70 @@ pub mod brand { !self.reader.get_pointer_field(0).is_null() } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.reader.get_data_field::(4) { 0 => { - ::std::result::Result::Ok(Bind( - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + ::core::result::Result::Ok(Bind( + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) )) } 1 => { - ::std::result::Result::Ok(Inherit( + ::core::result::Result::Ok(Inherit( () )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_scope_id(self) -> u64 { @@ -5154,37 +5210,37 @@ pub mod brand { self.builder.set_data_field::(0, value); } #[inline] - pub fn set_bind(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::brand::binding::Owned>) -> ::capnp::Result<()> { + pub fn set_bind(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::brand::binding::Owned>) -> ::capnp::Result<()> { self.builder.set_data_field::(4, 0); - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_bind(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::brand::binding::Owned> { + pub fn init_bind(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::brand::binding::Owned> { self.builder.set_data_field::(4, 0); ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), size) } pub fn has_bind(&self) -> bool { if self.builder.get_data_field::(4) != 0 { return false; } - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn set_inherit(&mut self, _value: ()) { self.builder.set_data_field::(4, 1); } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.builder.get_data_field::(4) { 0 => { - ::std::result::Result::Ok(Bind( - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + ::core::result::Result::Ok(Bind( + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) )) } 1 => { - ::std::result::Result::Ok(Inherit( + ::core::result::Result::Ok(Inherit( () )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -5206,8 +5262,8 @@ pub mod brand { Bind(A0), Inherit(()), } - pub type WhichReader<'a,> = Which<::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::brand::binding::Owned>>>; - pub type WhichBuilder<'a,> = Which<::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::brand::binding::Owned>>>; + pub type WhichReader<'a,A,> = Which<::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::brand::binding::Owned>>>; + pub type WhichBuilder<'a,A,> = Which<::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::brand::binding::Owned>>>; } pub mod binding { @@ -5215,43 +5271,45 @@ pub mod brand { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a[::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -5263,103 +5321,103 @@ pub mod brand { !self.reader.get_pointer_field(0).is_null() } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.reader.get_data_field::(0) { 0 => { - ::std::result::Result::Ok(Unbound( + ::core::result::Result::Ok(Unbound( () )) } 1 => { - ::std::result::Result::Ok(Type( - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + ::core::result::Result::Ok(Type( + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn set_unbound(&mut self, _value: ()) { self.builder.set_data_field::(0, 0); } #[inline] - pub fn set_type<'b>(&mut self, value: crate::schema_capnp::type_::Reader<'b>) -> ::capnp::Result<()> { + pub fn set_type<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::type_::Reader<'b,B>) -> ::capnp::Result<()> { self.builder.set_data_field::(0, 1); - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_type(self, ) -> crate::schema_capnp::type_::Builder<'a> { + pub fn init_type(self, ) -> crate::schema_capnp::type_::Builder<'a,A> { self.builder.set_data_field::(0, 1); ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0) } pub fn has_type(&self) -> bool { if self.builder.get_data_field::(0) != 1 { return false; } - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.builder.get_data_field::(0) { 0 => { - ::std::result::Result::Ok(Unbound( + ::core::result::Result::Ok(Unbound( () )) } 1 => { - ::std::result::Result::Ok(Type( - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + ::core::result::Result::Ok(Type( + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -5381,8 +5439,8 @@ pub mod brand { Unbound(()), Type(A0), } - pub type WhichReader<'a,> = Which<::capnp::Result>>; - pub type WhichBuilder<'a,> = Which<::capnp::Result>>; + pub type WhichReader<'a,A,> = Which<::capnp::Result>>; + pub type WhichBuilder<'a,A,> = Which<::capnp::Result>>; } } @@ -5391,43 +5449,45 @@ pub mod value { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a[::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -5455,155 +5515,155 @@ pub mod value { !self.reader.get_pointer_field(0).is_null() } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.reader.get_data_field::(0) { 0 => { - ::std::result::Result::Ok(Void( + ::core::result::Result::Ok(Void( () )) } 1 => { - ::std::result::Result::Ok(Bool( + ::core::result::Result::Ok(Bool( self.reader.get_bool_field(16) )) } 2 => { - ::std::result::Result::Ok(Int8( + ::core::result::Result::Ok(Int8( self.reader.get_data_field::(2) )) } 3 => { - ::std::result::Result::Ok(Int16( + ::core::result::Result::Ok(Int16( self.reader.get_data_field::(1) )) } 4 => { - ::std::result::Result::Ok(Int32( + ::core::result::Result::Ok(Int32( self.reader.get_data_field::(1) )) } 5 => { - ::std::result::Result::Ok(Int64( + ::core::result::Result::Ok(Int64( self.reader.get_data_field::(1) )) } 6 => { - ::std::result::Result::Ok(Uint8( + ::core::result::Result::Ok(Uint8( self.reader.get_data_field::(2) )) } 7 => { - ::std::result::Result::Ok(Uint16( + ::core::result::Result::Ok(Uint16( self.reader.get_data_field::(1) )) } 8 => { - ::std::result::Result::Ok(Uint32( + ::core::result::Result::Ok(Uint32( self.reader.get_data_field::(1) )) } 9 => { - ::std::result::Result::Ok(Uint64( + ::core::result::Result::Ok(Uint64( self.reader.get_data_field::(1) )) } 10 => { - ::std::result::Result::Ok(Float32( + ::core::result::Result::Ok(Float32( self.reader.get_data_field::(1) )) } 11 => { - ::std::result::Result::Ok(Float64( + ::core::result::Result::Ok(Float64( self.reader.get_data_field::(1) )) } 12 => { - ::std::result::Result::Ok(Text( - self.reader.get_pointer_field(0).get_text(None) + ::core::result::Result::Ok(Text( + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) )) } 13 => { - ::std::result::Result::Ok(Data( - self.reader.get_pointer_field(0).get_data(None) + ::core::result::Result::Ok(Data( + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) )) } 14 => { - ::std::result::Result::Ok(List( + ::core::result::Result::Ok(List( ::capnp::any_pointer::Reader::new(self.reader.get_pointer_field(0)) )) } 15 => { - ::std::result::Result::Ok(Enum( + ::core::result::Result::Ok(Enum( self.reader.get_data_field::(1) )) } 16 => { - ::std::result::Result::Ok(Struct( + ::core::result::Result::Ok(Struct( ::capnp::any_pointer::Reader::new(self.reader.get_pointer_field(0)) )) } 17 => { - ::std::result::Result::Ok(Interface( + ::core::result::Result::Ok(Interface( () )) } 18 => { - ::std::result::Result::Ok(AnyPointer( + ::core::result::Result::Ok(AnyPointer( ::capnp::any_pointer::Reader::new(self.reader.get_pointer_field(0)) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn set_void(&mut self, _value: ()) { @@ -5667,7 +5727,7 @@ pub mod value { #[inline] pub fn set_text(&mut self, value: ::capnp::text::Reader) { self.builder.set_data_field::(0, 12); - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_text(self, size: u32) -> ::capnp::text::Builder<'a> { @@ -5676,12 +5736,12 @@ pub mod value { } pub fn has_text(&self) -> bool { if self.builder.get_data_field::(0) != 12 { return false; } - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn set_data(&mut self, value: ::capnp::data::Reader) { self.builder.set_data_field::(0, 13); - self.builder.get_pointer_field(0).set_data(value); + self.builder.reborrow().get_pointer_field(0).set_data(value); } #[inline] pub fn init_data(self, size: u32) -> ::capnp::data::Builder<'a> { @@ -5690,10 +5750,10 @@ pub mod value { } pub fn has_data(&self) -> bool { if self.builder.get_data_field::(0) != 13 { return false; } - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] - pub fn init_list(self, ) -> ::capnp::any_pointer::Builder<'a> { + pub fn init_list(self, ) -> ::capnp::any_pointer::Builder<'a, A> { self.builder.set_data_field::(0, 14); let mut result = ::capnp::any_pointer::Builder::new(self.builder.get_pointer_field(0)); result.clear(); @@ -5701,7 +5761,7 @@ pub mod value { } pub fn has_list(&self) -> bool { if self.builder.get_data_field::(0) != 14 { return false; } - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn set_enum(&mut self, value: u16) { @@ -5709,7 +5769,7 @@ pub mod value { self.builder.set_data_field::(1, value); } #[inline] - pub fn init_struct(self, ) -> ::capnp::any_pointer::Builder<'a> { + pub fn init_struct(self, ) -> ::capnp::any_pointer::Builder<'a, A> { self.builder.set_data_field::(0, 16); let mut result = ::capnp::any_pointer::Builder::new(self.builder.get_pointer_field(0)); result.clear(); @@ -5717,14 +5777,14 @@ pub mod value { } pub fn has_struct(&self) -> bool { if self.builder.get_data_field::(0) != 16 { return false; } - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] pub fn set_interface(&mut self, _value: ()) { self.builder.set_data_field::(0, 17); } #[inline] - pub fn init_any_pointer(self, ) -> ::capnp::any_pointer::Builder<'a> { + pub fn init_any_pointer(self, ) -> ::capnp::any_pointer::Builder<'a, A> { self.builder.set_data_field::(0, 18); let mut result = ::capnp::any_pointer::Builder::new(self.builder.get_pointer_field(0)); result.clear(); @@ -5732,107 +5792,107 @@ pub mod value { } pub fn has_any_pointer(&self) -> bool { if self.builder.get_data_field::(0) != 18 { return false; } - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] - pub fn which(self) -> ::std::result::Result, ::capnp::NotInSchema> { + pub fn which(self) -> ::core::result::Result, ::capnp::NotInSchema> { match self.builder.get_data_field::(0) { 0 => { - ::std::result::Result::Ok(Void( + ::core::result::Result::Ok(Void( () )) } 1 => { - ::std::result::Result::Ok(Bool( + ::core::result::Result::Ok(Bool( self.builder.get_bool_field(16) )) } 2 => { - ::std::result::Result::Ok(Int8( + ::core::result::Result::Ok(Int8( self.builder.get_data_field::(2) )) } 3 => { - ::std::result::Result::Ok(Int16( + ::core::result::Result::Ok(Int16( self.builder.get_data_field::(1) )) } 4 => { - ::std::result::Result::Ok(Int32( + ::core::result::Result::Ok(Int32( self.builder.get_data_field::(1) )) } 5 => { - ::std::result::Result::Ok(Int64( + ::core::result::Result::Ok(Int64( self.builder.get_data_field::(1) )) } 6 => { - ::std::result::Result::Ok(Uint8( + ::core::result::Result::Ok(Uint8( self.builder.get_data_field::(2) )) } 7 => { - ::std::result::Result::Ok(Uint16( + ::core::result::Result::Ok(Uint16( self.builder.get_data_field::(1) )) } 8 => { - ::std::result::Result::Ok(Uint32( + ::core::result::Result::Ok(Uint32( self.builder.get_data_field::(1) )) } 9 => { - ::std::result::Result::Ok(Uint64( + ::core::result::Result::Ok(Uint64( self.builder.get_data_field::(1) )) } 10 => { - ::std::result::Result::Ok(Float32( + ::core::result::Result::Ok(Float32( self.builder.get_data_field::(1) )) } 11 => { - ::std::result::Result::Ok(Float64( + ::core::result::Result::Ok(Float64( self.builder.get_data_field::(1) )) } 12 => { - ::std::result::Result::Ok(Text( - self.builder.get_pointer_field(0).get_text(None) + ::core::result::Result::Ok(Text( + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) )) } 13 => { - ::std::result::Result::Ok(Data( - self.builder.get_pointer_field(0).get_data(None) + ::core::result::Result::Ok(Data( + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) )) } 14 => { - ::std::result::Result::Ok(List( + ::core::result::Result::Ok(List( ::capnp::any_pointer::Builder::new(self.builder.get_pointer_field(0)) )) } 15 => { - ::std::result::Result::Ok(Enum( + ::core::result::Result::Ok(Enum( self.builder.get_data_field::(1) )) } 16 => { - ::std::result::Result::Ok(Struct( + ::core::result::Result::Ok(Struct( ::capnp::any_pointer::Builder::new(self.builder.get_pointer_field(0)) )) } 17 => { - ::std::result::Result::Ok(Interface( + ::core::result::Result::Ok(Interface( () )) } 18 => { - ::std::result::Result::Ok(AnyPointer( + ::core::result::Result::Ok(AnyPointer( ::capnp::any_pointer::Builder::new(self.builder.get_pointer_field(0)) )) } - x => ::std::result::Result::Err(::capnp::NotInSchema(x)) + x => ::core::result::Result::Err(::capnp::NotInSchema(x)) } } } @@ -5871,50 +5931,52 @@ pub mod value { Interface(()), AnyPointer(A4), } - pub type WhichReader<'a,> = Which<::capnp::Result<::capnp::text::Reader<'a>>,::capnp::Result<::capnp::data::Reader<'a>>,::capnp::any_pointer::Reader<'a>,::capnp::any_pointer::Reader<'a>,::capnp::any_pointer::Reader<'a>>; - pub type WhichBuilder<'a,> = Which<::capnp::Result<::capnp::text::Builder<'a>>,::capnp::Result<::capnp::data::Builder<'a>>,::capnp::any_pointer::Builder<'a>,::capnp::any_pointer::Builder<'a>,::capnp::any_pointer::Builder<'a>>; + pub type WhichReader<'a,A,> = Which<::capnp::Result<::capnp::text::Reader<'a>>,::capnp::Result<::capnp::data::Reader<'a>>,::capnp::any_pointer::Reader<'a,A>,::capnp::any_pointer::Reader<'a,A>,::capnp::any_pointer::Reader<'a,A>>; + pub type WhichBuilder<'a,A,> = Which<::capnp::Result<::capnp::text::Builder<'a>>,::capnp::Result<::capnp::data::Builder<'a>>,::capnp::any_pointer::Builder<'a,A>,::capnp::any_pointer::Builder<'a,A>,::capnp::any_pointer::Builder<'a,A>>; } pub mod annotation { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -5926,68 +5988,68 @@ pub mod annotation { self.reader.get_data_field::(0) } #[inline] - pub fn get_value(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + pub fn get_value(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_value(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(1), ::core::option::Option::None) } pub fn has_brand(&self) -> bool { !self.reader.get_pointer_field(1).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_id(self) -> u64 { @@ -5998,34 +6060,34 @@ pub mod annotation { self.builder.set_data_field::(0, value); } #[inline] - pub fn get_value(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + pub fn get_value(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] - pub fn set_value<'b>(&mut self, value: crate::schema_capnp::value::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + pub fn set_value<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::value::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_value(self, ) -> crate::schema_capnp::value::Builder<'a> { + pub fn init_value(self, ) -> crate::schema_capnp::value::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), 0) } pub fn has_value(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] - pub fn get_brand(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), None) + pub fn get_brand(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None) } #[inline] - pub fn set_brand<'b>(&mut self, value: crate::schema_capnp::brand::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(1), value, false) + pub fn set_brand<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::brand::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false) } #[inline] - pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a> { + pub fn init_brand(self, ) -> crate::schema_capnp::brand::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), 0) } pub fn has_brand(&self) -> bool { - !self.builder.get_pointer_field(1).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(1).is_null() } } @@ -6064,17 +6126,17 @@ pub enum ElementSize { } impl ::capnp::traits::FromU16 for ElementSize { #[inline] - fn from_u16(value: u16) -> ::std::result::Result { + fn from_u16(value: u16) -> ::core::result::Result { match value { - 0 => ::std::result::Result::Ok(ElementSize::Empty), - 1 => ::std::result::Result::Ok(ElementSize::Bit), - 2 => ::std::result::Result::Ok(ElementSize::Byte), - 3 => ::std::result::Result::Ok(ElementSize::TwoBytes), - 4 => ::std::result::Result::Ok(ElementSize::FourBytes), - 5 => ::std::result::Result::Ok(ElementSize::EightBytes), - 6 => ::std::result::Result::Ok(ElementSize::Pointer), - 7 => ::std::result::Result::Ok(ElementSize::InlineComposite), - n => ::std::result::Result::Err(::capnp::NotInSchema(n)), + 0 => ::core::result::Result::Ok(ElementSize::Empty), + 1 => ::core::result::Result::Ok(ElementSize::Bit), + 2 => ::core::result::Result::Ok(ElementSize::Byte), + 3 => ::core::result::Result::Ok(ElementSize::TwoBytes), + 4 => ::core::result::Result::Ok(ElementSize::FourBytes), + 5 => ::core::result::Result::Ok(ElementSize::EightBytes), + 6 => ::core::result::Result::Ok(ElementSize::Pointer), + 7 => ::core::result::Result::Ok(ElementSize::InlineComposite), + n => ::core::result::Result::Err(::capnp::NotInSchema(n)), } } } @@ -6090,43 +6152,45 @@ impl ::capnp::traits::HasTypeId for ElementSize { pub mod capnp_version { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } + + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -6147,53 +6211,53 @@ pub mod capnp_version { } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_major(self) -> u16 { @@ -6239,43 +6303,45 @@ pub mod capnp_version { pub mod code_generator_request { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a[::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -6283,142 +6349,142 @@ pub mod code_generator_request { self.reader.total_size() } #[inline] - pub fn get_nodes(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::node::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(0), None) + pub fn get_nodes(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_nodes(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } #[inline] - pub fn get_requested_files(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::code_generator_request::requested_file::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), None) + pub fn get_requested_files(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::code_generator_request::requested_file::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(1), ::core::option::Option::None) } pub fn has_requested_files(&self) -> bool { !self.reader.get_pointer_field(1).is_null() } #[inline] - pub fn get_capnp_version(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(2), None) + pub fn get_capnp_version(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(2), ::core::option::Option::None) } pub fn has_capnp_version(&self) -> bool { !self.reader.get_pointer_field(2).is_null() } #[inline] - pub fn get_source_info(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::node::source_info::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(3), None) + pub fn get_source_info(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::source_info::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(3), ::core::option::Option::None) } pub fn has_source_info(&self) -> bool { !self.reader.get_pointer_field(3).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] - pub fn get_nodes(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::node::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), None) + pub fn get_nodes(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] - pub fn set_nodes(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::node::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(0), value, false) + pub fn set_nodes(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(0), value, false) } #[inline] - pub fn init_nodes(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::node::Owned> { + pub fn init_nodes(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(0), size) } pub fn has_nodes(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] - pub fn get_requested_files(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::code_generator_request::requested_file::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), None) + pub fn get_requested_files(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::code_generator_request::requested_file::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None) } #[inline] - pub fn set_requested_files(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::code_generator_request::requested_file::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(1), value, false) + pub fn set_requested_files(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::code_generator_request::requested_file::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false) } #[inline] - pub fn init_requested_files(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::code_generator_request::requested_file::Owned> { + pub fn init_requested_files(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::code_generator_request::requested_file::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), size) } pub fn has_requested_files(&self) -> bool { - !self.builder.get_pointer_field(1).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(1).is_null() } #[inline] - pub fn get_capnp_version(self) -> ::capnp::Result> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), None) + pub fn get_capnp_version(self) -> ::capnp::Result> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(2), ::core::option::Option::None) } #[inline] - pub fn set_capnp_version<'b>(&mut self, value: crate::schema_capnp::capnp_version::Reader<'b>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(2), value, false) + pub fn set_capnp_version<'b, B: ::capnp::private::arena::ReaderArena >(&mut self, value: crate::schema_capnp::capnp_version::Reader<'b,B>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(2), value, false) } #[inline] - pub fn init_capnp_version(self, ) -> crate::schema_capnp::capnp_version::Builder<'a> { + pub fn init_capnp_version(self, ) -> crate::schema_capnp::capnp_version::Builder<'a,A> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(2), 0) } pub fn has_capnp_version(&self) -> bool { - !self.builder.get_pointer_field(2).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(2).is_null() } #[inline] - pub fn get_source_info(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::node::source_info::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), None) + pub fn get_source_info(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::source_info::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(3), ::core::option::Option::None) } #[inline] - pub fn set_source_info(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::node::source_info::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(3), value, false) + pub fn set_source_info(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::node::source_info::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(3), value, false) } #[inline] - pub fn init_source_info(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::node::source_info::Owned> { + pub fn init_source_info(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::node::source_info::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(3), size) } pub fn has_source_info(&self) -> bool { - !self.builder.get_pointer_field(3).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(3).is_null() } } @@ -6442,43 +6508,45 @@ pub mod code_generator_request { pub mod requested_file { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -6491,67 +6559,67 @@ pub mod code_generator_request { } #[inline] pub fn get_filename(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_filename(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } #[inline] - pub fn get_imports(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,crate::schema_capnp::code_generator_request::requested_file::import::Owned>> { - ::capnp::traits::FromPointerReader::get_from_pointer(&self.reader.get_pointer_field(1), None) + pub fn get_imports(self) -> ::capnp::Result<::capnp::struct_list::Reader<'a,A,crate::schema_capnp::code_generator_request::requested_file::import::Owned>> { + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(1), ::core::option::Option::None) } pub fn has_imports(&self) -> bool { !self.reader.get_pointer_field(1).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_id(self) -> u64 { @@ -6563,33 +6631,33 @@ pub mod code_generator_request { } #[inline] pub fn get_filename(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_filename(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_filename(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_filename(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } #[inline] - pub fn get_imports(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,crate::schema_capnp::code_generator_request::requested_file::import::Owned>> { - ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), None) + pub fn get_imports(self) -> ::capnp::Result<::capnp::struct_list::Builder<'a,A,crate::schema_capnp::code_generator_request::requested_file::import::Owned>> { + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(1), ::core::option::Option::None) } #[inline] - pub fn set_imports(&mut self, value: ::capnp::struct_list::Reader<'a,crate::schema_capnp::code_generator_request::requested_file::import::Owned>) -> ::capnp::Result<()> { - ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.get_pointer_field(1), value, false) + pub fn set_imports(&mut self, value: ::capnp::struct_list::Reader<'a,A,crate::schema_capnp::code_generator_request::requested_file::import::Owned>) -> ::capnp::Result<()> { + ::capnp::traits::SetPointerBuilder::set_pointer_builder(self.builder.reborrow().get_pointer_field(1), value, false) } #[inline] - pub fn init_imports(self, size: u32) -> ::capnp::struct_list::Builder<'a,crate::schema_capnp::code_generator_request::requested_file::import::Owned> { + pub fn init_imports(self, size: u32) -> ::capnp::struct_list::Builder<'a,A,crate::schema_capnp::code_generator_request::requested_file::import::Owned> { ::capnp::traits::FromPointerBuilder::init_pointer(self.builder.get_pointer_field(1), size) } pub fn has_imports(&self) -> bool { - !self.builder.get_pointer_field(1).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(1).is_null() } } @@ -6610,43 +6678,45 @@ pub mod code_generator_request { pub mod import { #[derive(Copy, Clone)] pub struct Owned; - impl <'a> ::capnp::traits::Owned<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } - impl <'a> ::capnp::traits::OwnedStruct<'a> for Owned { type Reader = Reader<'a>; type Builder = Builder<'a>; } + impl capnp::traits::Owned for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } + impl ::capnp::traits::OwnedStruct for Owned { type Reader<'a, A: ::capnp::private::arena::ReaderArena + 'a> = Reader<'a, A>; type Builder<'a, A: ::capnp::private::arena::BuilderArena + 'a> = Builder<'a, A>; } impl ::capnp::traits::Pipelined for Owned { type Pipeline = Pipeline; } - #[derive(Clone, Copy)] - pub struct Reader<'a> { reader: ::capnp::private::layout::StructReader<'a> } + pub struct Reader<'a, A> { reader: ::capnp::private::layout::StructReader<&'a A> } - impl <'a,> ::capnp::traits::HasTypeId for Reader<'a,> { + impl <'a, A> Clone for Reader<'a,A> { fn clone(&self) -> Self { Self { reader: self.reader.clone() } } } + impl <'a, A> Copy for Reader<'a,A> {} + + impl <'a, A, > ::capnp::traits::HasTypeId for Reader<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructReader<'a> for Reader<'a,> { - fn new(reader: ::capnp::private::layout::StructReader<'a>) -> Reader<'a,> { - Reader { reader: reader, } + impl <'a,A,> ::capnp::traits::FromStructReader<'a, A> for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn new(reader: ::capnp::private::layout::StructReader<&'a A>) -> Reader<'a,A,> { + Reader { reader, } } } - impl <'a,> ::capnp::traits::FromPointerReader<'a> for Reader<'a,> { - fn get_from_pointer(reader: &::capnp::private::layout::PointerReader<'a>, default: Option<&'a[::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) + impl <'a,A,> ::capnp::traits::FromPointerReader<'a, A> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + fn get_from_pointer(reader: ::capnp::private::layout::PointerReader<&'a A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructReader::new(reader.get_struct(default)?)) } } - impl <'a,> ::capnp::traits::IntoInternalStructReader<'a> for Reader<'a,> { - fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<'a> { + impl <'a,A,> ::capnp::traits::IntoInternalStructReader<'a,A> for Reader<'a,A,> { + fn into_internal_struct_reader(self) -> ::capnp::private::layout::StructReader<&'a A> { self.reader } } - impl <'a,> ::capnp::traits::Imbue<'a> for Reader<'a,> { + impl <'a,A,> ::capnp::traits::Imbue<'a> for Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { fn imbue(&mut self, cap_table: &'a ::capnp::private::layout::CapTable) { self.reader.imbue(::capnp::private::layout::CapTableReader::Plain(cap_table)) } } - impl <'a,> Reader<'a,> { - pub fn reborrow(&self) -> Reader<> { + impl <'a,A,> Reader<'a,A,> where A: ::capnp::private::arena::ReaderArena { + pub fn reborrow(&self) -> Reader { Reader { .. *self } } @@ -6659,60 +6729,60 @@ pub mod code_generator_request { } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Reader<'a>> { - self.reader.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerReader::get_from_pointer(self.reader.get_pointer_field(0), ::core::option::Option::None) } pub fn has_name(&self) -> bool { !self.reader.get_pointer_field(0).is_null() } } - pub struct Builder<'a> { builder: ::capnp::private::layout::StructBuilder<'a> } - impl <'a,> ::capnp::traits::HasStructSize for Builder<'a,> { + pub struct Builder<'a, A> { builder: ::capnp::private::layout::StructBuilder<&'a mut A> } + impl <'a,A,> ::capnp::traits::HasStructSize for Builder<'a,A,> { #[inline] fn struct_size() -> ::capnp::private::layout::StructSize { _private::STRUCT_SIZE } } - impl <'a,> ::capnp::traits::HasTypeId for Builder<'a,> { + impl <'a,A,> ::capnp::traits::HasTypeId for Builder<'a,A,> { #[inline] fn type_id() -> u64 { _private::TYPE_ID } } - impl <'a,> ::capnp::traits::FromStructBuilder<'a> for Builder<'a,> { - fn new(builder: ::capnp::private::layout::StructBuilder<'a>) -> Builder<'a, > { - Builder { builder: builder, } + impl <'a, A, > ::capnp::traits::FromStructBuilder<'a, A> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { + fn new(builder: ::capnp::private::layout::StructBuilder<&'a mut A>) -> Builder<'a, A, > { + Builder { builder, } } } - impl <'a,> ::capnp::traits::ImbueMut<'a> for Builder<'a,> { + impl <'a,A,> ::capnp::traits::ImbueMut<'a> for Builder<'a,A,> where A: ::capnp::private::arena::BuilderArena { fn imbue_mut(&mut self, cap_table: &'a mut ::capnp::private::layout::CapTable) { self.builder.imbue(::capnp::private::layout::CapTableBuilder::Plain(cap_table)) } } - impl <'a,> ::capnp::traits::FromPointerBuilder<'a> for Builder<'a,> { - fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, _size: u32) -> Builder<'a,> { + impl <'a, A, > ::capnp::traits::FromPointerBuilder<'a, A> for Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + fn init_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, _size: u32) -> Builder<'a, A, > { ::capnp::traits::FromStructBuilder::new(builder.init_struct(_private::STRUCT_SIZE)) } - fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<'a>, default: Option<&'a [::capnp::Word]>) -> ::capnp::Result> { - ::std::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) + fn get_from_pointer(builder: ::capnp::private::layout::PointerBuilder<&'a mut A>, default: ::core::option::Option<&'a [capnp::Word]>) -> ::capnp::Result> { + ::core::result::Result::Ok(::capnp::traits::FromStructBuilder::new(builder.get_struct(_private::STRUCT_SIZE, default)?)) } } - impl <'a,> ::capnp::traits::SetPointerBuilder> for Reader<'a,> { - fn set_pointer_builder<'b>(pointer: ::capnp::private::layout::PointerBuilder<'b>, value: Reader<'a,>, canonicalize: bool) -> ::capnp::Result<()> { pointer.set_struct(&value.reader, canonicalize) } + impl <'a, A, > ::capnp::traits::SetPointerBuilder for Reader<'a, A, > where A: ::capnp::private::arena::ReaderArena { + fn set_pointer_builder<'b, B>(pointer: ::capnp::private::layout::PointerBuilder<&'b mut B>, value: Reader<'a, A, >, canonicalize: bool) -> ::capnp::Result<()> where B: ::capnp::private::arena::BuilderArena { pointer.set_struct(&value.reader, canonicalize) } } - impl <'a,> Builder<'a,> { - pub fn into_reader(self) -> Reader<'a,> { + impl <'a, A, > Builder<'a, A, > where A: ::capnp::private::arena::BuilderArena { + pub fn into_reader(self) -> Reader<'a,A, > { ::capnp::traits::FromStructReader::new(self.builder.into_reader()) } - pub fn reborrow(&mut self) -> Builder<> { - Builder { .. *self } + pub fn reborrow(&mut self) -> Builder { + Builder { builder: self.builder.reborrow() } } - pub fn reborrow_as_reader(&self) -> Reader<> { - ::capnp::traits::FromStructReader::new(self.builder.into_reader()) + pub fn reborrow_as_reader(&self) -> Reader { + ::capnp::traits::FromStructReader::new(self.builder.reborrow_as_reader()) } pub fn total_size(&self) -> ::capnp::Result<::capnp::MessageSize> { - self.builder.into_reader().total_size() + self.builder.reborrow_as_reader().total_size() } #[inline] pub fn get_id(self) -> u64 { @@ -6724,18 +6794,18 @@ pub mod code_generator_request { } #[inline] pub fn get_name(self) -> ::capnp::Result<::capnp::text::Builder<'a>> { - self.builder.get_pointer_field(0).get_text(None) + ::capnp::traits::FromPointerBuilder::get_from_pointer(self.builder.get_pointer_field(0), ::core::option::Option::None) } #[inline] pub fn set_name(&mut self, value: ::capnp::text::Reader) { - self.builder.get_pointer_field(0).set_text(value); + self.builder.reborrow().get_pointer_field(0).set_text(value); } #[inline] pub fn init_name(self, size: u32) -> ::capnp::text::Builder<'a> { self.builder.get_pointer_field(0).init_text(size) } pub fn has_name(&self) -> bool { - !self.builder.get_pointer_field(0).is_null() + !self.builder.reborrow_as_reader().get_pointer_field(0).is_null() } }