diff --git a/rs/macros/core/src/service/mod.rs b/rs/macros/core/src/service/mod.rs index c05d4403..85b8863a 100644 --- a/rs/macros/core/src/service/mod.rs +++ b/rs/macros/core/src/service/mod.rs @@ -17,7 +17,7 @@ // along with this program. If not, see . //! Supporting functions and structures for the `gservice` macro. - +#![allow(unused_variables)] // temporary use crate::{ sails_paths, shared::{self, Func}, @@ -30,7 +30,7 @@ use proc_macro_error::abort; use quote::{format_ident, quote}; use std::collections::BTreeMap; use syn::{ - parse_quote, punctuated::Punctuated, spanned::Spanned, token::Comma, Ident, ImplItemFn, + parse_quote, punctuated::Punctuated, spanned::Spanned, token::Comma, Ident, ImplItemFn, Index, ItemImpl, Lifetime, Path, Type, Visibility, }; @@ -367,39 +367,64 @@ fn generate_gservice(args: TokenStream, service_impl: ItemImpl) -> TokenStream { quote! {} }; + let mut base_expo_types = Vec::with_capacity(service_args.base_types().len()); let mut base_types_funcs = Vec::with_capacity(service_args.base_types().len()); let mut base_types_impl = Vec::with_capacity(service_args.base_types().len()); let mut base_exposure_instantiation = Vec::with_capacity(service_args.base_types().len()); // let mut invocation_dispatches = Vec::with_capacity(service_handlers.len()); + let single_base_type = service_args.base_types().len() == 1; service_args.base_types().iter() .enumerate() .for_each(|(idx, base_type)| { - let as_base_ident = Ident::new(&format!("as_base_{}", idx), Span::call_site()); + let as_base_ident = format_ident!("as_base_{}", idx); + let base_idx = Index::from(idx); + + base_expo_types.push(quote! { + #sails_path::gstd::services::ServiceExposure< #base_type, () > + }); base_types_funcs.push(quote!{ - fn #as_base_ident (&self) -> &< #base_type as #sails_path::gstd::services::Service>::Exposure; + fn #as_base_ident (&self) -> & #sails_path::gstd::services::ServiceExposure< #base_type, () >; }); + let extend_ref = if single_base_type { + quote! { &self.extend } + } else { + quote! { &self.extend.#base_idx } + }; + base_types_impl.push(quote!{ - fn #as_base_ident (&self) -> &< #base_type as #sails_path::gstd::services::Service>::Exposure { - &self.extend.#idx + fn #as_base_ident (&self) -> & #sails_path::gstd::services::ServiceExposure< #base_type, () > { + #extend_ref } }); base_exposure_instantiation.push(quote!( - < #base_type as Clone>::clone(AsRef::< #base_type >::as_ref( #inner_ident )).expose( #message_id_ident , #route_ident ), + < #base_type as Clone>::clone(AsRef::< #base_type >::as_ref( &self )).expose( #message_id_ident , #route_ident ) )); }); + let base_type = if single_base_type { + let single_type = &base_expo_types[0]; + quote! { #single_type } + } else { + quote! { ( #( #base_expo_types ),* ) } + }; + let base_inst: TokenStream = quote! { ( #( #base_exposure_instantiation ),* ) }; + quote!( #service_impl pub trait #trait_ident #trait_lifetimes { #( #trait_funcs )* + + #( #base_types_funcs )* } - impl #generics #trait_ident #trait_lifetimes for #sails_path::gstd::services::ServiceExposure< #exposure_args, () > #service_type_constraints { + impl #generics #trait_ident #trait_lifetimes for #sails_path::gstd::services::ServiceExposure< #service_type_path, #base_type > #service_type_constraints { #( #trait_funcs_impl )* + + #( #base_types_impl )* } impl #generics #sails_path::gstd::services::ServiceHandle for #service_type_path #service_type_constraints { @@ -414,11 +439,11 @@ fn generate_gservice(args: TokenStream, service_impl: ItemImpl) -> TokenStream { } impl #generics #sails_path::gstd::services::Service for #service_type_path #service_type_constraints { - type Exposure = #sails_path::gstd::services::ServiceExposure< #exposure_args, () >; - type Extend = (); + type Exposure = #sails_path::gstd::services::ServiceExposure< #service_type_path, #base_type >; + type Extend = #base_type; fn expose(self, #message_id_ident : #sails_path::MessageId, #route_ident : &'static [u8]) -> Self::Exposure { - let extend = (); + let extend = #base_inst; Self::Exposure::new(#message_id_ident, #route_ident, self, extend) } } diff --git a/rs/macros/core/tests/snapshots/gservice__works_with_extends.snap b/rs/macros/core/tests/snapshots/gservice__works_with_extends.snap index 4362e805..fcbe1b4d 100644 --- a/rs/macros/core/tests/snapshots/gservice__works_with_extends.snap +++ b/rs/macros/core/tests/snapshots/gservice__works_with_extends.snap @@ -9,13 +9,35 @@ impl SomeService { } pub trait SomeServiceImplTrait { fn do_this(&mut self) -> u32; + fn as_base_0( + &self, + ) -> &sails_rs::gstd::services::ServiceExposure; + fn as_base_1( + &self, + ) -> &sails_rs::gstd::services::ServiceExposure; } impl SomeServiceImplTrait -for sails_rs::gstd::services::ServiceExposure { +for sails_rs::gstd::services::ServiceExposure< + SomeService, + ( + sails_rs::gstd::services::ServiceExposure, + sails_rs::gstd::services::ServiceExposure, + ), +> { fn do_this(&mut self) -> u32 { let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new2(self); self.inner.do_this() } + fn as_base_0( + &self, + ) -> &sails_rs::gstd::services::ServiceExposure { + &self.extend.0 + } + fn as_base_1( + &self, + ) -> &sails_rs::gstd::services::ServiceExposure { + &self.extend.1 + } } impl sails_rs::gstd::services::ServiceHandle for SomeService { async fn try_handle(&mut self, input: &[u8]) -> Option<(Vec, u128)> { @@ -36,14 +58,28 @@ impl sails_rs::gstd::services::ServiceHandle for SomeService { } } impl sails_rs::gstd::services::Service for SomeService { - type Exposure = sails_rs::gstd::services::ServiceExposure; - type Extend = (); + type Exposure = sails_rs::gstd::services::ServiceExposure< + SomeService, + ( + sails_rs::gstd::services::ServiceExposure, + sails_rs::gstd::services::ServiceExposure, + ), + >; + type Extend = ( + sails_rs::gstd::services::ServiceExposure, + sails_rs::gstd::services::ServiceExposure, + ); fn expose( self, message_id: sails_rs::MessageId, route: &'static [u8], ) -> Self::Exposure { - let extend = (); + let extend = ( + ::clone(AsRef::::as_ref(&self)) + .expose(message_id, route), + ::clone(AsRef::::as_ref(&self)) + .expose(message_id, route), + ); Self::Exposure::new(message_id, route, self, extend) } } diff --git a/rs/macros/core/tests/snapshots/gservice__works_with_extends_and_lifetimes.snap b/rs/macros/core/tests/snapshots/gservice__works_with_extends_and_lifetimes.snap index 73aa1c3d..24d5dc66 100644 --- a/rs/macros/core/tests/snapshots/gservice__works_with_extends_and_lifetimes.snap +++ b/rs/macros/core/tests/snapshots/gservice__works_with_extends_and_lifetimes.snap @@ -13,9 +13,15 @@ impl<'a> ExtendedLifetime<'a> { pub trait ExtendedLifetimeImplTrait<'a> { fn extended_name(&self) -> String; fn name(&self) -> String; + fn as_base_0( + &self, + ) -> &sails_rs::gstd::services::ServiceExposure, ()>; } impl<'a> ExtendedLifetimeImplTrait<'a> -for sails_rs::gstd::services::ServiceExposure<'a, ExtendedLifetime<'a>, ()> { +for sails_rs::gstd::services::ServiceExposure< + ExtendedLifetime<'a>, + sails_rs::gstd::services::ServiceExposure, ()>, +> { fn extended_name(&self) -> String { let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new2(self); self.inner.extended_name() @@ -24,6 +30,11 @@ for sails_rs::gstd::services::ServiceExposure<'a, ExtendedLifetime<'a>, ()> { let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new2(self); self.inner.name() } + fn as_base_0( + &self, + ) -> &sails_rs::gstd::services::ServiceExposure, ()> { + &self.extend + } } impl<'a> sails_rs::gstd::services::ServiceHandle for ExtendedLifetime<'a> { async fn try_handle(&mut self, input: &[u8]) -> Option<(Vec, u128)> { @@ -54,17 +65,19 @@ impl<'a> sails_rs::gstd::services::ServiceHandle for ExtendedLifetime<'a> { } impl<'a> sails_rs::gstd::services::Service for ExtendedLifetime<'a> { type Exposure = sails_rs::gstd::services::ServiceExposure< - 'a, ExtendedLifetime<'a>, - (), + sails_rs::gstd::services::ServiceExposure, ()>, >; - type Extend = (); + type Extend = sails_rs::gstd::services::ServiceExposure, ()>; fn expose( self, message_id: sails_rs::MessageId, route: &'static [u8], ) -> Self::Exposure { - let extend = (); + let extend = ( as Clone>::clone(AsRef::>::as_ref(&self)) + .expose(message_id, route)); Self::Exposure::new(message_id, route, self, extend) } } diff --git a/rs/macros/tests/gservice_tests.rs b/rs/macros/tests/gservice_tests.rs index 2d536c10..26edd273 100644 --- a/rs/macros/tests/gservice_tests.rs +++ b/rs/macros/tests/gservice_tests.rs @@ -3,8 +3,8 @@ use sails_rs::{Decode, Encode, MessageId}; mod gservice_with_basics; mod gservice_with_events; -// mod gservice_with_extends; -// mod gservice_with_extends_and_lifetimes; +mod gservice_with_extends; +mod gservice_with_extends_and_lifetimes; mod gservice_with_lifecycles_and_generics; mod gservice_with_lifetimes_and_events; mod gservice_with_multiple_names; @@ -42,52 +42,52 @@ async fn gservice_with_basics() { assert_eq!(output.len(), 0); } -// #[tokio::test] -// async fn gservice_with_extends() { -// use gservice_with_extends::{ -// base::{Base, BASE_NAME_RESULT}, -// extended::{Extended, EXTENDED_NAME_RESULT, NAME_RESULT}, -// }; +#[tokio::test] +async fn gservice_with_extends() { + use gservice_with_extends::{ + base::{Base, BASE_NAME_RESULT}, + extended::{Extended, ExtendedImplTrait, EXTENDED_NAME_RESULT, NAME_RESULT}, + }; -// const NAME_METHOD: &str = "Name"; -// const BASE_NAME_METHOD: &str = "BaseName"; -// const EXTENDED_NAME_METHOD: &str = "ExtendedName"; + const NAME_METHOD: &str = "Name"; + const BASE_NAME_METHOD: &str = "BaseName"; + const EXTENDED_NAME_METHOD: &str = "ExtendedName"; -// let mut extended_svc = Extended::new(Base).expose(123.into(), &[1, 2, 3]); + let mut extended_svc = Extended::new(Base).expose(123.into(), &[1, 2, 3]); -// let (output, _value) = extended_svc.handle(&EXTENDED_NAME_METHOD.encode()).await; + let (output, _value) = extended_svc.handle(&EXTENDED_NAME_METHOD.encode()).await; -// assert_eq!( -// output, -// [EXTENDED_NAME_METHOD.encode(), EXTENDED_NAME_RESULT.encode()].concat() -// ); + assert_eq!( + output, + [EXTENDED_NAME_METHOD.encode(), EXTENDED_NAME_RESULT.encode()].concat() + ); -// let _base: &::Exposure = extended_svc.as_base_0(); + let _base: &::Exposure = extended_svc.as_base_0(); -// let (output, _value) = extended_svc.handle(&BASE_NAME_METHOD.encode()).await; -// let mut output = output.as_slice(); -// let func_name = String::decode(&mut output).unwrap(); -// assert_eq!(func_name, BASE_NAME_METHOD); + let (output, _value) = extended_svc.handle(&BASE_NAME_METHOD.encode()).await; + let mut output = output.as_slice(); + let func_name = String::decode(&mut output).unwrap(); + assert_eq!(func_name, BASE_NAME_METHOD); -// let result = String::decode(&mut output).unwrap(); -// assert_eq!(result, BASE_NAME_RESULT); + let result = String::decode(&mut output).unwrap(); + assert_eq!(result, BASE_NAME_RESULT); -// let (output, _value) = extended_svc.handle(&EXTENDED_NAME_METHOD.encode()).await; -// let mut output = output.as_slice(); -// let func_name = String::decode(&mut output).unwrap(); -// assert_eq!(func_name, EXTENDED_NAME_METHOD); + let (output, _value) = extended_svc.handle(&EXTENDED_NAME_METHOD.encode()).await; + let mut output = output.as_slice(); + let func_name = String::decode(&mut output).unwrap(); + assert_eq!(func_name, EXTENDED_NAME_METHOD); -// let result = String::decode(&mut output).unwrap(); -// assert_eq!(result, EXTENDED_NAME_RESULT); + let result = String::decode(&mut output).unwrap(); + assert_eq!(result, EXTENDED_NAME_RESULT); -// let (output, _value) = extended_svc.handle(&NAME_METHOD.encode()).await; -// let mut output = output.as_slice(); -// let func_name = String::decode(&mut output).unwrap(); -// assert_eq!(func_name, NAME_METHOD); + let (output, _value) = extended_svc.handle(&NAME_METHOD.encode()).await; + let mut output = output.as_slice(); + let func_name = String::decode(&mut output).unwrap(); + assert_eq!(func_name, NAME_METHOD); -// let result = String::decode(&mut output).unwrap(); -// assert_eq!(result, NAME_RESULT); -// } + let result = String::decode(&mut output).unwrap(); + assert_eq!(result, NAME_RESULT); +} #[tokio::test] async fn gservice_with_lifecycles_and_generics() { @@ -201,54 +201,56 @@ async fn gservice_with_lifetimes_and_events() { assert_eq!(events[0], MyEvents::Event1); } -// #[tokio::test] -// async fn gservice_with_extends_and_lifetimes() { -// use gservice_with_extends_and_lifetimes::{ -// base::{BaseWithLifetime, BASE_NAME_RESULT}, -// extended::{ExtendedWithLifetime, EXTENDED_NAME_RESULT, NAME_RESULT}, -// }; +#[tokio::test] +async fn gservice_with_extends_and_lifetimes() { + use gservice_with_extends_and_lifetimes::{ + base::{BaseWithLifetime, BASE_NAME_RESULT}, + extended::{ + ExtendedWithLifetime, ExtendedWithLifetimeImplTrait, EXTENDED_NAME_RESULT, NAME_RESULT, + }, + }; -// const NAME_METHOD: &str = "Name"; -// const BASE_NAME_METHOD: &str = "BaseName"; -// const EXTENDED_NAME_METHOD: &str = "ExtendedName"; + const NAME_METHOD: &str = "Name"; + const BASE_NAME_METHOD: &str = "BaseName"; + const EXTENDED_NAME_METHOD: &str = "ExtendedName"; -// let int = 42u64; -// let mut extended_svc = -// ExtendedWithLifetime::new(BaseWithLifetime::new(&int)).expose(123.into(), &[1, 2, 3]); + let int = 42u64; + let mut extended_svc = + ExtendedWithLifetime::new(BaseWithLifetime::new(&int)).expose(123.into(), &[1, 2, 3]); -// let (output, _value) = extended_svc.handle(&EXTENDED_NAME_METHOD.encode()).await; + let (output, _value) = extended_svc.handle(&EXTENDED_NAME_METHOD.encode()).await; -// assert_eq!( -// output, -// [EXTENDED_NAME_METHOD.encode(), EXTENDED_NAME_RESULT.encode()].concat() -// ); + assert_eq!( + output, + [EXTENDED_NAME_METHOD.encode(), EXTENDED_NAME_RESULT.encode()].concat() + ); -// let _base: &::Exposure = extended_svc.as_base_0(); + let _base: &::Exposure = extended_svc.as_base_0(); -// let (output, _value) = extended_svc.handle(&BASE_NAME_METHOD.encode()).await; -// let mut output = output.as_slice(); -// let func_name = String::decode(&mut output).unwrap(); -// assert_eq!(func_name, BASE_NAME_METHOD); + let (output, _value) = extended_svc.handle(&BASE_NAME_METHOD.encode()).await; + let mut output = output.as_slice(); + let func_name = String::decode(&mut output).unwrap(); + assert_eq!(func_name, BASE_NAME_METHOD); -// let result = String::decode(&mut output).unwrap(); -// assert_eq!(result, BASE_NAME_RESULT); + let result = String::decode(&mut output).unwrap(); + assert_eq!(result, BASE_NAME_RESULT); -// let (output, _value) = extended_svc.handle(&EXTENDED_NAME_METHOD.encode()).await; -// let mut output = output.as_slice(); -// let func_name = String::decode(&mut output).unwrap(); -// assert_eq!(func_name, EXTENDED_NAME_METHOD); + let (output, _value) = extended_svc.handle(&EXTENDED_NAME_METHOD.encode()).await; + let mut output = output.as_slice(); + let func_name = String::decode(&mut output).unwrap(); + assert_eq!(func_name, EXTENDED_NAME_METHOD); -// let result = String::decode(&mut output).unwrap(); -// assert_eq!(result, EXTENDED_NAME_RESULT); + let result = String::decode(&mut output).unwrap(); + assert_eq!(result, EXTENDED_NAME_RESULT); -// let (output, _value) = extended_svc.handle(&NAME_METHOD.encode()).await; -// let mut output = output.as_slice(); -// let func_name = String::decode(&mut output).unwrap(); -// assert_eq!(func_name, NAME_METHOD); + let (output, _value) = extended_svc.handle(&NAME_METHOD.encode()).await; + let mut output = output.as_slice(); + let func_name = String::decode(&mut output).unwrap(); + assert_eq!(func_name, NAME_METHOD); -// let result = String::decode(&mut output).unwrap(); -// assert_eq!(result, NAME_RESULT); -// } + let result = String::decode(&mut output).unwrap(); + assert_eq!(result, NAME_RESULT); +} #[tokio::test] async fn gservice_with_reply_with_value() { diff --git a/rs/macros/tests/some_service.rs b/rs/macros/tests/some_service.rs deleted file mode 100644 index 0d790262..00000000 --- a/rs/macros/tests/some_service.rs +++ /dev/null @@ -1,460 +0,0 @@ -#![no_std] -#![allow(unused_imports, dead_code, unused_variables)] -use sails_rs::gstd::services::*; -use sails_rs::prelude::*; - -struct MyProgram; - -const __ROUTE_SERVICE2: [u8; 9usize] = [32u8, 83u8, 101u8, 114u8, 118u8, 105u8, 99u8, 101u8, 50u8]; -const __ROUTE_SVC1: [u8; 5usize] = [16u8, 83u8, 118u8, 99u8, 49u8]; -impl MyProgram { - #[route("svc1")] - pub fn service1(&self) -> ::Exposure { - let service = self.__service1(); - let exposure = ::expose( - service, - sails_rs::gstd::msg::id().into(), - __ROUTE_SVC1.as_ref(), - ); - exposure - } - pub fn service2(&self) -> ::Exposure { - let service = self.__service2(); - let exposure = ::expose( - service, - sails_rs::gstd::msg::id().into(), - __ROUTE_SERVICE2.as_ref(), - ); - exposure - } - fn __service2(&self) -> SomeService { - SomeService - } - fn __service1(&self) -> SomeService { - SomeService - } - pub fn default() -> Self { - Self - } -} -impl sails_rs::meta::ProgramMeta for MyProgram { - fn constructors() -> sails_rs::scale_info::MetaType { - sails_rs::scale_info::MetaType::new::() - } - fn services() -> impl Iterator { - [ - ( - "Service2", - sails_rs::meta::AnyServiceMeta::new::(), - ), - ("Svc1", sails_rs::meta::AnyServiceMeta::new::()), - ] - .into_iter() - } -} -use sails_rs::Decode as __ProgramDecode; -use sails_rs::TypeInfo as __ProgramTypeInfo; -#[derive(__ProgramDecode, __ProgramTypeInfo)] -#[codec(crate = sails_rs::scale_codec)] -#[scale_info(crate = sails_rs::scale_info)] -#[allow(dead_code)] -struct __DefaultParams {} -mod meta_in_program { - use super::*; - #[derive(__ProgramTypeInfo)] - #[scale_info(crate = sails_rs::scale_info)] - pub enum ConstructorsMeta { - Default(__DefaultParams), - } -} -#[cfg(target_arch = "wasm32")] -pub mod wasm { - use super::*; - use sails_rs::{gstd, hex, prelude::*}; - static mut PROGRAM: Option = None; - #[gstd::async_init] - async fn init() { - sails_rs::gstd::events::__enable_events(); - let mut input: &[u8] = &gstd::msg::load_bytes().expect("Failed to read input"); - let (program, invocation_route) = - if input.starts_with(&[28u8, 68u8, 101u8, 102u8, 97u8, 117u8, 108u8, 116u8]) { - static INVOCATION_ROUTE: [u8; 8usize] = - [28u8, 68u8, 101u8, 102u8, 97u8, 117u8, 108u8, 116u8]; - let request = __DefaultParams::decode(&mut &input[8usize..]) - .expect("Failed to decode request"); - let program = MyProgram::default(); - (program, INVOCATION_ROUTE.as_ref()) - } else { - let mut __input = input; - let input: String = sails_rs::Decode::decode(&mut __input).unwrap_or_else(|_| { - if input.len() <= 8 { - format!("0x{}", sails_rs::hex::encode(input)) - } else { - format!( - "0x{}..{}", - sails_rs::hex::encode(&input[..4]), - sails_rs::hex::encode(&input[input.len() - 4..]) - ) - } - }); - panic!("Unexpected ctor: {}", input) - }; - unsafe { - PROGRAM = Some(program); - } - gstd::msg::reply_bytes(invocation_route, 0).expect("Failed to send output"); - } - #[gstd::async_main] - async fn main() { - let mut input: &[u8] = &gstd::msg::load_bytes().expect("Failed to read input"); - let (output, value): (Vec, ValueUnit) = if input.starts_with(&__ROUTE_SERVICE2) { - let program_ref = unsafe { PROGRAM.as_ref() }.expect("Program not initialized"); - let mut service = program_ref.service2(); - let (output, value) = service.handle(&input[__ROUTE_SERVICE2.len()..]).await; - ([__ROUTE_SERVICE2.as_ref(), &output].concat(), value) - } else if input.starts_with(&__ROUTE_SVC1) { - let program_ref = unsafe { PROGRAM.as_ref() }.expect("Program not initialized"); - let mut service = program_ref.service1(); - let (output, value) = service.handle(&input[__ROUTE_SVC1.len()..]).await; - ([__ROUTE_SVC1.as_ref(), &output].concat(), value) - } else { - let mut __input = input; - let input: String = sails_rs::Decode::decode(&mut __input).unwrap_or_else(|_| { - if input.len() <= 8 { - format!("0x{}", sails_rs::hex::encode(input)) - } else { - format!( - "0x{}..{}", - sails_rs::hex::encode(&input[..4]), - sails_rs::hex::encode(&input[input.len() - 4..]) - ) - } - }); - panic!("Unexpected service: {}", input) - }; - gstd::msg::reply_bytes(output, value).expect("Failed to send output"); - } -} - -pub struct SomeService; -impl SomeService { - pub async fn do_this(&mut self, p1: u32, p2: String) -> u32 { - p1 - } - pub fn this(&self, p1: bool) -> bool { - p1 - } -} - -trait __SomeServiceImplTrait { - async fn do_this(&mut self, p1: u32, p2: String) -> u32; - fn this(&self, p1: bool) -> bool; -} - -// pub struct SomeServiceExposure { -// message_id: sails_rs::MessageId, -// route: &'static [u8], -// #[cfg(not(target_arch = "wasm32"))] -// inner: Box, -// #[cfg(not(target_arch = "wasm32"))] -// inner_ptr: *const T, -// #[cfg(target_arch = "wasm32")] -// inner: T, -// } -// impl ServiceExposure { -// pub async fn do_this(&mut self, p1: u32, p2: String) -> u32 { -// self.call_scoped(|s| s.do_this(p1, p2)).await -// // let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new(self); -// // self.inner.do_this(p1, p2).await -// } -// pub fn this(&self, p1: bool) -> bool { -// let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new(self); -// self.inner.this(p1) -// } -// pub async fn handle(&mut self, input: &[u8]) -> (Vec, u128) { -// self.try_handle(input).await.unwrap_or_else(|| { -// let mut __input = input; -// let input: String = sails_rs::Decode::decode(&mut __input).unwrap_or_else(|_| { -// if input.len() <= 8 { -// format!("0x{}", sails_rs::hex::encode(input)) -// } else { -// format!( -// "0x{}..{}", -// sails_rs::hex::encode(&input[..4]), -// sails_rs::hex::encode(&input[input.len() - 4..]) -// ) -// } -// }); -// panic!("Unknown request: {}", input) -// }) -// } -// pub async fn try_handle(&mut self, input: &[u8]) -> Option<(Vec, u128)> { -// if input.starts_with(&[24u8, 68u8, 111u8, 84u8, 104u8, 105u8, 115u8]) { -// let (output, value) = self.__do_this(&input[7usize..]).await; -// static INVOCATION_ROUTE: [u8; 7usize] = [24u8, 68u8, 111u8, 84u8, 104u8, 105u8, 115u8]; -// return Some(([INVOCATION_ROUTE.as_ref(), &output].concat(), value)); -// } -// if input.starts_with(&[16u8, 84u8, 104u8, 105u8, 115u8]) { -// let (output, value) = self.__this(&input[5usize..]).await; -// static INVOCATION_ROUTE: [u8; 5usize] = [16u8, 84u8, 104u8, 105u8, 115u8]; -// return Some(([INVOCATION_ROUTE.as_ref(), &output].concat(), value)); -// } -// None -// } -// async fn __do_this(&mut self, mut input: &[u8]) -> (Vec, u128) { -// let request: some_service_meta::__DoThisParams = -// sails_rs::Decode::decode(&mut input).expect("Failed to decode request"); -// let result = self.do_this(request.p1, request.p2).await; -// let value = 0u128; -// return (sails_rs::Encode::encode(&result), value); -// } -// async fn __this(&self, mut input: &[u8]) -> (Vec, u128) { -// let request: some_service_meta::__ThisParams = -// sails_rs::Decode::decode(&mut input).expect("Failed to decode request"); -// let result = self.this(request.p1); -// let value = 0u128; -// return (sails_rs::Encode::encode(&result), value); -// } -// } -// impl sails_rs::gstd::services::Exposure for SomeServiceExposure { -// type Service = SomeService; - -// fn message_id(&self) -> sails_rs::MessageId { -// self.message_id -// } -// fn route(&self) -> &'static [u8] { -// self.route -// } -// } - -#[allow(unused_parens)] -impl __SomeServiceImplTrait - for ServiceExposure)> -{ - async fn do_this(&mut self, p1: u32, p2: String) -> u32 { - let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new2(self); - self.inner.do_this(p1, p2).await - } - fn this(&self, p1: bool) -> bool { - let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new2(self); - self.inner.this(p1) - } -} - -#[allow(unused_parens)] -impl sails_rs::gstd::services::Service for SomeService { - type Exposure = ServiceExposure)>; - type Extend = (ServiceExposure); - - fn expose(self, message_id: sails_rs::MessageId, route: &'static [u8]) -> Self::Exposure { - let extend = ::clone(AsRef::::as_ref(&self)) - .expose(message_id, route); - Self::Exposure::new(message_id, route, self, extend) - } -} - -impl sails_rs::gstd::services::ServiceHandle for SomeService { - async fn try_handle(&mut self, input: &[u8]) -> Option<(Vec, u128)> { - let mut __input = input; - let route: String = sails_rs::Decode::decode(&mut __input).ok()?; - match route.as_str() { - "DoThis" => { - let request: some_service_meta::__DoThisParams = - sails_rs::Decode::decode(&mut __input).expect("Failed to decode request"); - let result = self.do_this(request.p1, request.p2).await; - let value = 0u128; - Some((sails_rs::Encode::encode(&("DoThis", &result)), value)) - } - "This" => { - let request: some_service_meta::__ThisParams = - sails_rs::Decode::decode(&mut __input).expect("Failed to decode request"); - let result = self.this(request.p1); - let value = 0u128; - Some((sails_rs::Encode::encode(&("This", &result)), value)) - } - _ => None, - } - } -} - -impl sails_rs::meta::ServiceMeta for SomeService { - fn commands() -> sails_rs::scale_info::MetaType { - sails_rs::scale_info::MetaType::new::() - } - fn queries() -> sails_rs::scale_info::MetaType { - sails_rs::scale_info::MetaType::new::() - } - fn events() -> sails_rs::scale_info::MetaType { - sails_rs::scale_info::MetaType::new::() - } - fn base_services() -> impl Iterator { - [].into_iter() - } -} -mod some_service_meta { - use super::*; - use sails_rs::{Decode, TypeInfo}; - #[derive(Decode, TypeInfo)] - #[codec(crate = sails_rs::scale_codec)] - #[scale_info(crate = sails_rs::scale_info)] - pub struct __DoThisParams { - pub(super) p1: u32, - pub(super) p2: String, - } - #[derive(Decode, TypeInfo)] - #[codec(crate = sails_rs::scale_codec)] - #[scale_info(crate = sails_rs::scale_info)] - pub struct __ThisParams { - pub(super) p1: bool, - } - #[derive(TypeInfo)] - #[scale_info(crate = sails_rs::scale_info)] - pub enum CommandsMeta { - DoThis(__DoThisParams, u32), - } - #[derive(TypeInfo)] - #[scale_info(crate = sails_rs::scale_info)] - pub enum QueriesMeta { - This(__ThisParams, bool), - } - #[derive(TypeInfo)] - #[scale_info(crate = sails_rs::scale_info)] - pub enum NoEvents {} - pub type EventsMeta = NoEvents; -} - -#[derive(Debug, Clone)] -pub struct ExtendedService1; -impl ExtendedService1 { - pub async fn none() {} -} -impl Service for ExtendedService1 { - type Exposure = ServiceExposure; - type Extend = (); - - fn expose(self, message_id: MessageId, route: &'static [u8]) -> Self::Exposure { - Self::Exposure::new(message_id, route, self, ()) - } -} - -impl AsRef for SomeService { - fn as_ref(&self) -> &ExtendedService1 { - todo!() - } -} - -pub struct ReferenceService<'a> { - data: Option>, -} -struct ReferenceData<'a> { - num: &'a mut u8, - message: &'a str, -} - -impl<'t> ReferenceService<'t> { - pub async fn guess_num(&mut self, number: u8) -> Result<&'t str, &'static str> { - if number > 42 { - Err("Number is too large") - } else if let Some(data) = &self.data.as_ref() { - if *data.num == number { - Ok(data.message) - } else { - Err("Try again") - } - } else { - Err("Data is not set") - } - } - pub async fn message(&self) -> Option<&'t str> { - self.data.as_ref().map(|d| d.message) - } -} -trait __ReferenceServiceImplTrait<'t> { - async fn guess_num(&mut self, number: u8) -> Result<&'t str, &'static str>; - async fn message(&self) -> Option<&'t str>; -} -impl<'t> __ReferenceServiceImplTrait<'t> - for sails_rs::gstd::services::ServiceExposure, ()> -{ - async fn guess_num(&mut self, number: u8) -> Result<&'t str, &'static str> { - let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new2(self); - self.inner.guess_num(number).await - } - async fn message(&self) -> Option<&'t str> { - let exposure_scope = sails_rs::gstd::services::ExposureCallScope::new2(self); - self.inner.message().await - } -} -impl<'t> sails_rs::gstd::services::ServiceHandle for ReferenceService<'t> { - async fn try_handle(&mut self, input: &[u8]) -> Option<(Vec, u128)> { - let mut __input = input; - let route: String = sails_rs::Decode::decode(&mut __input).ok()?; - match route.as_str() { - "GuessNum" => { - let request: reference_service_meta::__GuessNumParams = - sails_rs::Decode::decode(&mut __input).expect("Failed to decode request"); - let result = self.guess_num(request.number).await; - let value = 0u128; - Some((sails_rs::Encode::encode(&("GuessNum", &result)), value)) - } - "Message" => { - let request: reference_service_meta::__MessageParams = - sails_rs::Decode::decode(&mut __input).expect("Failed to decode request"); - let result = self.message().await; - let value = 0u128; - Some((sails_rs::Encode::encode(&("Message", &result)), value)) - } - _ => None, - } - } -} -impl<'t> sails_rs::gstd::services::Service for ReferenceService<'t> { - type Exposure = sails_rs::gstd::services::ServiceExposure, ()>; - type Extend = (); - fn expose(self, message_id: sails_rs::MessageId, route: &'static [u8]) -> Self::Exposure { - let extend = (); - Self::Exposure::new(message_id, route, self, extend) - } -} -impl<'t> sails_rs::meta::ServiceMeta for ReferenceService<'t> { - fn commands() -> sails_rs::scale_info::MetaType { - sails_rs::scale_info::MetaType::new::() - } - fn queries() -> sails_rs::scale_info::MetaType { - sails_rs::scale_info::MetaType::new::() - } - fn events() -> sails_rs::scale_info::MetaType { - sails_rs::scale_info::MetaType::new::() - } - fn base_services() -> impl Iterator { - [].into_iter() - } -} -mod reference_service_meta { - use super::*; - use sails_rs::{Decode, TypeInfo}; - #[derive(Decode, TypeInfo)] - #[codec(crate = sails_rs::scale_codec)] - #[scale_info(crate = sails_rs::scale_info)] - pub struct __GuessNumParams { - pub(super) number: u8, - } - #[derive(Decode, TypeInfo)] - #[codec(crate = sails_rs::scale_codec)] - #[scale_info(crate = sails_rs::scale_info)] - pub struct __MessageParams {} - #[derive(TypeInfo)] - #[scale_info(crate = sails_rs::scale_info)] - pub enum CommandsMeta { - GuessNum(__GuessNumParams, Result<&'static str, &'static str>), - } - #[derive(TypeInfo)] - #[scale_info(crate = sails_rs::scale_info)] - pub enum QueriesMeta { - Message(__MessageParams, Option<&'static str>), - } - #[derive(TypeInfo)] - #[scale_info(crate = sails_rs::scale_info)] - pub enum NoEvents {} - pub type EventsMeta = NoEvents; -}