From 8679ae0a78baba8e95edcf900f5a1f5d99dec231 Mon Sep 17 00:00:00 2001 From: Orion Kindel Date: Tue, 11 Apr 2023 16:29:23 -0500 Subject: [PATCH] refactor: rework msg module structure --- build.sbt | 2 +- glue/src/dev/mod.rs | 1 + glue/src/dev/toad/ffi/mod.rs | 2 + glue/src/{ => dev/toad/ffi}/uint.rs | 0 .../{runtime_config.rs => dev/toad/mod.rs} | 157 +++++++++++++----- glue/src/dev/toad/msg/code.rs | 15 ++ glue/src/dev/toad/msg/mod.rs | 7 + glue/src/dev/toad/msg/ref_/mod.rs | 8 + glue/src/dev/toad/msg/ref_/msg.rs | 97 +++++++++++ glue/src/dev/toad/msg/ref_/opt.rs | 57 +++++++ glue/src/dev/toad/msg/ref_/opt_value.rs | 33 ++++ glue/src/dev/toad/msg/ty.rs | 36 ++++ glue/src/{ => dev/toad}/retry_strategy.rs | 10 +- glue/src/e2e.rs | 20 +-- glue/src/lib.rs | 34 ++-- glue/src/message_code.rs | 16 -- glue/src/message_opt_ref.rs | 57 ------- glue/src/message_opt_value_ref.rs | 34 ---- glue/src/message_ref.rs | 100 ----------- glue/src/message_type.rs | 37 ----- glue/src/runtime.rs | 78 --------- src/main/java/dev.toad/Client.java | 10 ++ .../dev.toad/{ToadRuntime.java => Toad.java} | 62 ++++--- .../msg/{MessageCode.java => Code.java} | 4 +- src/main/java/dev.toad/msg/Id.java | 14 ++ src/main/java/dev.toad/msg/Message.java | 10 +- src/main/java/dev.toad/msg/MessageOption.java | 9 - .../java/dev.toad/msg/MessageOptionOwned.java | 30 ---- .../java/dev.toad/msg/MessageOptionRef.java | 39 ----- .../dev.toad/msg/MessageOptionValueOwned.java | 23 --- src/main/java/dev.toad/msg/MessageOwned.java | 66 -------- src/main/java/dev.toad/msg/Option.java | 9 + ...ssageOptionValue.java => OptionValue.java} | 2 +- src/main/java/dev.toad/msg/Token.java | 14 ++ .../msg/{MessageType.java => Type.java} | 6 +- src/main/java/dev.toad/msg/owned/Message.java | 85 ++++++++++ src/main/java/dev.toad/msg/owned/Option.java | 36 ++++ .../java/dev.toad/msg/owned/OptionValue.java | 22 +++ .../msg/{MessageRef.java => ref/Message.java} | 41 ++--- src/main/java/dev.toad/msg/ref/Option.java | 40 +++++ .../OptionValue.java} | 12 +- 41 files changed, 703 insertions(+), 632 deletions(-) create mode 100644 glue/src/dev/mod.rs create mode 100644 glue/src/dev/toad/ffi/mod.rs rename glue/src/{ => dev/toad/ffi}/uint.rs (100%) rename glue/src/{runtime_config.rs => dev/toad/mod.rs} (52%) create mode 100644 glue/src/dev/toad/msg/code.rs create mode 100644 glue/src/dev/toad/msg/mod.rs create mode 100644 glue/src/dev/toad/msg/ref_/mod.rs create mode 100644 glue/src/dev/toad/msg/ref_/msg.rs create mode 100644 glue/src/dev/toad/msg/ref_/opt.rs create mode 100644 glue/src/dev/toad/msg/ref_/opt_value.rs create mode 100644 glue/src/dev/toad/msg/ty.rs rename glue/src/{ => dev/toad}/retry_strategy.rs (89%) delete mode 100644 glue/src/message_code.rs delete mode 100644 glue/src/message_opt_ref.rs delete mode 100644 glue/src/message_opt_value_ref.rs delete mode 100644 glue/src/message_ref.rs delete mode 100644 glue/src/message_type.rs delete mode 100644 glue/src/runtime.rs create mode 100644 src/main/java/dev.toad/Client.java rename src/main/java/dev.toad/{ToadRuntime.java => Toad.java} (85%) rename src/main/java/dev.toad/msg/{MessageCode.java => Code.java} (91%) create mode 100644 src/main/java/dev.toad/msg/Id.java delete mode 100644 src/main/java/dev.toad/msg/MessageOption.java delete mode 100644 src/main/java/dev.toad/msg/MessageOptionOwned.java delete mode 100644 src/main/java/dev.toad/msg/MessageOptionRef.java delete mode 100644 src/main/java/dev.toad/msg/MessageOptionValueOwned.java delete mode 100644 src/main/java/dev.toad/msg/MessageOwned.java create mode 100644 src/main/java/dev.toad/msg/Option.java rename src/main/java/dev.toad/msg/{MessageOptionValue.java => OptionValue.java} (68%) create mode 100644 src/main/java/dev.toad/msg/Token.java rename src/main/java/dev.toad/msg/{MessageType.java => Type.java} (80%) create mode 100644 src/main/java/dev.toad/msg/owned/Message.java create mode 100644 src/main/java/dev.toad/msg/owned/Option.java create mode 100644 src/main/java/dev.toad/msg/owned/OptionValue.java rename src/main/java/dev.toad/msg/{MessageRef.java => ref/Message.java} (59%) create mode 100644 src/main/java/dev.toad/msg/ref/Option.java rename src/main/java/dev.toad/msg/{MessageOptionValueRef.java => ref/OptionValue.java} (61%) diff --git a/build.sbt b/build.sbt index 1840d3d..0ab1779 100644 --- a/build.sbt +++ b/build.sbt @@ -29,7 +29,7 @@ lazy val root = project Compile / doc / javacOptions ++= Seq( "--enable-preview", "--release", - "20", + "20" ), Compile / compile / javacOptions ++= Seq( "--enable-preview", diff --git a/glue/src/dev/mod.rs b/glue/src/dev/mod.rs new file mode 100644 index 0000000..47c9faa --- /dev/null +++ b/glue/src/dev/mod.rs @@ -0,0 +1 @@ +pub mod toad; diff --git a/glue/src/dev/toad/ffi/mod.rs b/glue/src/dev/toad/ffi/mod.rs new file mode 100644 index 0000000..db71dcf --- /dev/null +++ b/glue/src/dev/toad/ffi/mod.rs @@ -0,0 +1,2 @@ +mod uint; +pub use uint::{u16, u32, u64, u8}; diff --git a/glue/src/uint.rs b/glue/src/dev/toad/ffi/uint.rs similarity index 100% rename from glue/src/uint.rs rename to glue/src/dev/toad/ffi/uint.rs diff --git a/glue/src/runtime_config.rs b/glue/src/dev/toad/mod.rs similarity index 52% rename from glue/src/runtime_config.rs rename to glue/src/dev/toad/mod.rs index 5dcf727..3a06d02 100644 --- a/glue/src/runtime_config.rs +++ b/glue/src/dev/toad/mod.rs @@ -1,42 +1,95 @@ +pub mod ffi; +pub mod msg; + +mod retry_strategy; use std::net::{Ipv4Addr, SocketAddr}; -use jni::objects::JClass; +use jni::objects::{JClass, JObject}; use jni::sys::jobject; -use toad::config::{self, BytesPerSecond, Config}; +pub use retry_strategy::RetryStrategy; +use toad::platform::Platform; use toad::retry::{Attempts, Strategy}; use toad::time::Millis; -use toad_jni::java::{self, Class, Object}; +use toad_jni::java::{self, Object}; -use crate::retry_strategy::RetryStrategy; -use crate::uint; +use crate::mem::{Shared, SharedMemoryRegion}; +use crate::Runtime; -pub struct RuntimeConfig(java::lang::Object); +pub struct Toad(java::lang::Object); -java::object_newtype!(RuntimeConfig); -impl java::Class for RuntimeConfig { - const PATH: &'static str = concat!(package!(dev.toad.ToadRuntime), "$Config"); +impl Toad { + pub fn new(e: &mut java::Env, cfg: Config) -> Self { + static CTOR: java::Constructor = java::Constructor::new(); + CTOR.invoke(e, cfg) + } + + pub fn poll_req(&self, e: &mut java::Env) -> Option { + static POLL_REQ: java::Method java::util::Optional> = + java::Method::new("pollReq"); + POLL_REQ.invoke(e, self).to_option(e) + } + + pub fn config(&self, e: &mut java::Env) -> Config { + static CONFIG: java::Method Config> = java::Method::new("config"); + CONFIG.invoke(e, self) + } + + fn init_impl(e: &mut java::Env, cfg: Config) -> i64 { + let r = || Runtime::try_new(cfg.addr(e), cfg.to_toad(e)).unwrap(); + unsafe { crate::mem::Shared::init(r).addr() as i64 } + } + + fn poll_req_impl(e: &mut java::Env, addr: i64) -> java::util::Optional { + match unsafe { + Shared::deref::(/* TODO */ 0, addr).as_ref() + .unwrap() + }.poll_req() + { + | Ok(req) => { + let mr = msg::ref_::Message::new(e, req.unwrap().into()); + java::util::Optional::::of(e, mr) + }, + | Err(nb::Error::WouldBlock) => java::util::Optional::::empty(e), + | Err(nb::Error::Other(err)) => { + e.throw(format!("{:?}", err)).unwrap(); + java::util::Optional::::empty(e) + }, + } + } } -impl RuntimeConfig { +java::object_newtype!(Toad); + +impl java::Class for Toad { + const PATH: &'static str = package!(dev.toad.Toad); +} + +pub struct Config(java::lang::Object); + +java::object_newtype!(Config); +impl java::Class for Config { + const PATH: &'static str = concat!(package!(dev.toad.Toad), "$Config"); +} + +impl Config { pub fn addr(&self, e: &mut java::Env) -> SocketAddr { - static ADDRESS: java::Field = - java::Field::new("addr"); + static ADDRESS: java::Field = java::Field::new("addr"); ADDRESS.get(e, self).to_std(e) } pub fn concurrency(&self, e: &mut java::Env) -> u8 { - static RUNTIME_CONFIG_CONCURRENCY: java::Field = + static RUNTIME_CONFIG_CONCURRENCY: java::Field = java::Field::new("concurrency"); RUNTIME_CONFIG_CONCURRENCY.get(e, self).to_rust(e) } pub fn msg(&self, e: &mut java::Env) -> Msg { - static RUNTIME_CONFIG_MSG: java::Method Msg> = java::Method::new("msg"); + static RUNTIME_CONFIG_MSG: java::Method Msg> = java::Method::new("msg"); RUNTIME_CONFIG_MSG.invoke(e, self) } - pub fn new(e: &mut java::Env, c: Config, addr: SocketAddr) -> Self { - static CTOR: java::Constructor = + pub fn new(e: &mut java::Env, c: toad::config::Config, addr: SocketAddr) -> Self { + static CTOR: java::Constructor = java::Constructor::new(); let con = Con::new(e, @@ -51,7 +104,7 @@ impl RuntimeConfig { con, non); - let concurrency = uint::u8::from_rust(e, c.max_concurrent_requests); + let concurrency = ffi::u8::from_rust(e, c.max_concurrent_requests); let address = java::net::InetSocketAddress::from_std(e, addr); @@ -59,23 +112,23 @@ impl RuntimeConfig { jcfg } - pub fn to_toad(&self, e: &mut java::Env) -> config::Config { + pub fn to_toad(&self, e: &mut java::Env) -> toad::config::Config { let msg = self.msg(e); let con = msg.con(e); let non = msg.non(e); - config::Config { max_concurrent_requests: self.concurrency(e) as u8, - msg: config::Msg { token_seed: msg.token_seed(e) as _, - probing_rate: BytesPerSecond(msg.probing_rate(e) as _), + toad::config::Config { max_concurrent_requests: self.concurrency(e) as u8, + msg: toad::config::Msg { token_seed: msg.token_seed(e) as _, + probing_rate: toad::config::BytesPerSecond(msg.probing_rate(e) as _), multicast_response_leisure: msg.multicast_response_leisure(e), - con: config::Con { unacked_retry_strategy: + con: toad::config::Con { unacked_retry_strategy: con.unacked_retry_strategy(e), acked_retry_strategy: con.acked_retry_strategy(e), max_attempts: Attempts(con.max_attempts(e) as _) }, - non: config::Non { retry_strategy: + non: toad::config::Non { retry_strategy: non.retry_strategy(e), max_attempts: Attempts(non.max_attempts(e) as _) } } } @@ -87,7 +140,7 @@ pub struct Msg(java::lang::Object); java::object_newtype!(Msg); impl java::Class for Msg { - const PATH: &'static str = concat!(package!(dev.toad.ToadRuntime), "$Config$Msg"); + const PATH: &'static str = concat!(package!(dev.toad.Toad), "$Config$Msg"); } impl Msg { @@ -98,10 +151,10 @@ impl Msg { con: Con, non: Non) -> Self { - static CTOR: java::Constructor = + static CTOR: java::Constructor = java::Constructor::new(); - let token_seed = uint::u16::from_rust(e, token_seed); - let probe_rate = uint::u16::from_rust(e, probe_rate); + let token_seed = ffi::u16::from_rust(e, token_seed); + let probe_rate = ffi::u16::from_rust(e, probe_rate); let multicast_response_leisure = java::time::Duration::of_millis(e, multicast_response_leisure.0 as i64); @@ -147,20 +200,20 @@ pub struct Con(java::lang::Object); java::object_newtype!(Con); impl java::Class for Con { - const PATH: &'static str = concat!(package!(dev.toad.ToadRuntime), "$Config$Msg$Con"); + const PATH: &'static str = concat!(package!(dev.toad.Toad), "$Config$Msg$Con"); } impl Con { pub fn new(e: &mut java::Env, - unacked: toad::retry::Strategy, - acked: toad::retry::Strategy, + unacked: Strategy, + acked: Strategy, max_attempts: Attempts) -> Self { - static CTOR: java::Constructor = + static CTOR: java::Constructor = java::Constructor::new(); let unacked = RetryStrategy::from_toad(e, unacked); let acked = RetryStrategy::from_toad(e, acked); - let att = uint::u16::from_rust(e, max_attempts.0); + let att = ffi::u16::from_rust(e, max_attempts.0); CTOR.invoke(e, unacked, acked, att) } @@ -186,14 +239,14 @@ pub struct Non(java::lang::Object); java::object_newtype!(Non); impl java::Class for Non { - const PATH: &'static str = concat!(package!(dev.toad.ToadRuntime), "$Config$Msg$Non"); + const PATH: &'static str = concat!(package!(dev.toad.Toad), "$Config$Msg$Non"); } impl Non { - pub fn new(e: &mut java::Env, strat: toad::retry::Strategy, max_attempts: Attempts) -> Self { - static CTOR: java::Constructor = java::Constructor::new(); + pub fn new(e: &mut java::Env, strat: Strategy, max_attempts: Attempts) -> Self { + static CTOR: java::Constructor = java::Constructor::new(); let strat = RetryStrategy::from_toad(e, strat); - let att = uint::u16::from_rust(e, max_attempts.0); + let att = ffi::u16::from_rust(e, max_attempts.0); CTOR.invoke(e, strat, att) } @@ -210,10 +263,30 @@ impl Non { } #[no_mangle] -pub extern "system" fn Java_dev_toad_Runtime_defaultConfigImpl<'local>(mut env: java::Env<'local>, - _: JClass<'local>) - -> jobject { - RuntimeConfig::new(&mut env, - Config::default(), - SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), 5683)).yield_to_java(&mut env) +pub extern "system" fn Java_dev_toad_Toad_defaultConfigImpl<'local>(mut env: java::Env<'local>, + _: JClass<'local>) + -> jobject { + Config::new(&mut env, + toad::config::Config::default(), + SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), 5683)).yield_to_java(&mut env) +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_Toad_init<'local>(mut e: java::Env<'local>, + _: JClass<'local>, + cfg: JObject<'local>) + -> i64 { + let e = &mut e; + let cfg = java::lang::Object::from_local(e, cfg).upcast_to::(e); + + Toad::init_impl(e, cfg) +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_Toad_pollReq<'local>(mut e: java::Env<'local>, + _: JClass<'local>, + addr: i64) + -> jobject { + let e = &mut e; + Toad::poll_req_impl(e, addr).yield_to_java(e) } diff --git a/glue/src/dev/toad/msg/code.rs b/glue/src/dev/toad/msg/code.rs new file mode 100644 index 0000000..9f093e0 --- /dev/null +++ b/glue/src/dev/toad/msg/code.rs @@ -0,0 +1,15 @@ +use toad_jni::java; + +pub struct Code(java::lang::Object); + +java::object_newtype!(Code); +impl java::Class for Code { + const PATH: &'static str = package!(dev.toad.msg.Code); +} + +impl Code { + pub fn new(e: &mut java::Env, code: toad_msg::Code) -> Self { + static CTOR: java::Constructor = java::Constructor::new(); + CTOR.invoke(e, code.class.into(), code.detail.into()) + } +} diff --git a/glue/src/dev/toad/msg/mod.rs b/glue/src/dev/toad/msg/mod.rs new file mode 100644 index 0000000..42fcf59 --- /dev/null +++ b/glue/src/dev/toad/msg/mod.rs @@ -0,0 +1,7 @@ +pub mod ref_; + +mod ty; +pub use ty::Type; + +mod code; +pub use code::Code; diff --git a/glue/src/dev/toad/msg/ref_/mod.rs b/glue/src/dev/toad/msg/ref_/mod.rs new file mode 100644 index 0000000..9f14030 --- /dev/null +++ b/glue/src/dev/toad/msg/ref_/mod.rs @@ -0,0 +1,8 @@ +mod opt; +pub use opt::Opt; + +mod msg; +pub use msg::Message; + +mod opt_value; +pub use opt_value::OptValue; diff --git a/glue/src/dev/toad/msg/ref_/msg.rs b/glue/src/dev/toad/msg/ref_/msg.rs new file mode 100644 index 0000000..9207c37 --- /dev/null +++ b/glue/src/dev/toad/msg/ref_/msg.rs @@ -0,0 +1,97 @@ +use jni::objects::JClass; +use jni::sys::jobject; +use toad_jni::java::{self, Object}; + +use crate::dev::toad::msg::ref_::Opt; +use crate::dev::toad::msg::{Code, Type}; +use crate::mem::{Shared, SharedMemoryRegion}; + +pub struct Message(java::lang::Object); + +java::object_newtype!(Message); +impl java::Class for Message { + const PATH: &'static str = package!(dev.toad.msg.ref.Message); +} + +impl Message { + pub fn new(env: &mut java::Env, message: toad_msg::alloc::Message) -> Self { + let ptr = unsafe { Shared::alloc_message(message) }; + static CTOR: java::Constructor = java::Constructor::new(); + CTOR.invoke(env, ptr.addr() as i64) + } + + pub fn close(&self, env: &mut java::Env) { + static CLOSE: java::Method = java::Method::new("close"); + CLOSE.invoke(env, self) + } + + pub fn ty(&self, env: &mut java::Env) -> toad_msg::Type { + static TYPE: java::Method Type> = java::Method::new("type"); + TYPE.invoke(env, self).to_toad(env) + } + + pub unsafe fn ptr<'a>(addr: i64) -> &'a mut toad_msg::alloc::Message { + crate::mem::Shared::deref::(/* TODO */ 0, addr).as_mut() + .unwrap() + } +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_ref_Message_id<'local>(mut env: java::Env<'local>, + _: JClass<'local>, + addr: i64) + -> i32 { + let msg = unsafe { Message::ptr(addr) }; + msg.id.0 as i32 +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_ref_Message_token<'local>(mut env: java::Env<'local>, + _: JClass<'local>, + addr: i64) + -> jobject { + let msg = unsafe { Message::ptr(addr) }; + env.byte_array_from_slice(&msg.token.0).unwrap().as_raw() +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_ref_Message_payload<'local>(mut env: java::Env<'local>, + _: JClass<'local>, + addr: i64) + -> jobject { + let msg = unsafe { Message::ptr(addr) }; + env.byte_array_from_slice(&msg.payload.0).unwrap().as_raw() +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_ref_Message_type<'local>(mut e: java::Env<'local>, + _: JClass<'local>, + addr: i64) + -> jobject { + let msg = unsafe { Message::ptr(addr) }; + Type::new(&mut e, msg.ty).yield_to_java(&mut e) +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_ref_Message_code<'local>(mut e: java::Env<'local>, + _: JClass<'local>, + addr: i64) + -> jobject { + let msg = unsafe { Message::ptr(addr) }; + Code::new(&mut e, msg.code).yield_to_java(&mut e) +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_ref_Message_opts<'local>(mut e: java::Env<'local>, + _: JClass<'local>, + addr: i64) + -> jobject { + let msg = unsafe { Message::ptr(addr) }; + let opts = &msg.opts; + + let refs = opts.into_iter() + .map(|(n, v)| Opt::new(&mut e, v as *const _ as i64, n.0.into())) + .collect::>(); + + refs.yield_to_java(&mut e) +} diff --git a/glue/src/dev/toad/msg/ref_/opt.rs b/glue/src/dev/toad/msg/ref_/opt.rs new file mode 100644 index 0000000..a1d0977 --- /dev/null +++ b/glue/src/dev/toad/msg/ref_/opt.rs @@ -0,0 +1,57 @@ +use jni::objects::{JClass, JObject}; +use jni::sys::jobject; +use jni::JNIEnv; +use toad_jni::java::{self, Object}; +use toad_msg::OptNumber; + +use super::OptValue; +use crate::mem::SharedMemoryRegion; + +pub struct Opt(pub java::lang::Object); + +java::object_newtype!(Opt); + +impl java::Class for Opt { + const PATH: &'static str = package!(dev.toad.msg.ref.Option); +} + +impl Opt { + pub fn new(env: &mut java::Env, addr: i64, num: i64) -> Self { + static CTOR: java::Constructor = java::Constructor::new(); + CTOR.invoke(env, addr, num) + } + + pub fn number(&self, env: &mut java::Env) -> OptNumber { + static NUMBER: java::Field = java::Field::new("number"); + OptNumber(NUMBER.get(env, self) as u32) + } + + pub unsafe fn values_ptr<'a>(addr: i64) -> &'a mut Vec>> { + crate::mem::Shared::deref::>>>(/* TODO */ 0, addr).as_mut() + .unwrap() + } +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_Option_number<'local>(mut env: JNIEnv<'local>, + o: JObject<'local>, + p: i64) + -> i64 { + java::lang::Object::from_local(&mut env, o).upcast_to::(&mut env) + .number(&mut env) + .0 as i64 +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_Option_values<'local>(mut e: JNIEnv<'local>, + _: JClass<'local>, + p: i64) + -> jobject { + let o = &unsafe { Opt::values_ptr(p) }; + + let refs = o.iter() + .map(|v| OptValue::new(&mut e, (&v.0 as *const Vec).addr() as i64)) + .collect::>(); + + refs.yield_to_java(&mut e) +} diff --git a/glue/src/dev/toad/msg/ref_/opt_value.rs b/glue/src/dev/toad/msg/ref_/opt_value.rs new file mode 100644 index 0000000..18b0f2b --- /dev/null +++ b/glue/src/dev/toad/msg/ref_/opt_value.rs @@ -0,0 +1,33 @@ +use jni::objects::JClass; +use jni::sys::jobject; +use toad_jni::java; + +use crate::mem::SharedMemoryRegion; + +pub struct OptValue(java::lang::Object); + +java::object_newtype!(OptValue); +impl java::Class for OptValue { + const PATH: &'static str = package!(dev.toad.msg.ref.OptionValue); +} + +impl OptValue { + pub fn new(env: &mut java::Env, addr: i64) -> Self { + static CTOR: java::Constructor = java::Constructor::new(); + CTOR.invoke(env, addr) + } + + pub unsafe fn ptr<'a>(addr: i64) -> &'a mut toad_msg::OptValue> { + crate::mem::Shared::deref::>>(/* TODO */ 0, addr).as_mut() + .unwrap() + } +} + +#[no_mangle] +pub extern "system" fn Java_dev_toad_msg_ref_OptionValue_bytes<'local>(mut env: java::Env<'local>, + _: JClass<'local>, + p: i64) + -> jobject { + let val = unsafe { OptValue::ptr(p) }; + env.byte_array_from_slice(val.as_bytes()).unwrap().as_raw() +} diff --git a/glue/src/dev/toad/msg/ty.rs b/glue/src/dev/toad/msg/ty.rs new file mode 100644 index 0000000..10dc1a1 --- /dev/null +++ b/glue/src/dev/toad/msg/ty.rs @@ -0,0 +1,36 @@ +use toad_jni::java; + +pub struct Type(java::lang::Object); + +java::object_newtype!(Type); +impl java::Class for Type { + const PATH: &'static str = package!(dev.toad.msg.Type); +} + +impl Type { + pub fn new(env: &mut java::Env, ty: toad_msg::Type) -> Self { + static FROM_STRING: java::StaticMethod Type> = + java::StaticMethod::new("fromString"); + + let str = match ty { + | toad_msg::Type::Con => "CON", + | toad_msg::Type::Non => "NON", + | toad_msg::Type::Ack => "ACK", + | toad_msg::Type::Reset => "RESET", + }; + + FROM_STRING.invoke(env, str.to_string()) + } + + pub fn to_toad(&self, env: &mut java::Env) -> toad_msg::Type { + static TO_STRING: java::Method String> = java::Method::new("toString"); + + match TO_STRING.invoke(env, self).trim().to_uppercase().as_str() { + | "CON" => toad_msg::Type::Con, + | "NON" => toad_msg::Type::Non, + | "ACK" => toad_msg::Type::Ack, + | "RESET" => toad_msg::Type::Reset, + | o => panic!("malformed message type {}", o), + } + } +} diff --git a/glue/src/retry_strategy.rs b/glue/src/dev/toad/retry_strategy.rs similarity index 89% rename from glue/src/retry_strategy.rs rename to glue/src/dev/toad/retry_strategy.rs index 4795344..cdaf969 100644 --- a/glue/src/retry_strategy.rs +++ b/glue/src/dev/toad/retry_strategy.rs @@ -2,7 +2,7 @@ use toad::retry::Strategy; use toad::time::Millis; use toad_jni::java::{self, Object}; -use crate::uint; +use crate::dev::toad::ffi; pub struct RetryStrategyExp(java::lang::Object); @@ -26,12 +26,12 @@ impl RetryStrategyExp { } pub fn init_min(&self, e: &mut java::Env) -> Millis { - static INIT_MIN: java::Field = java::Field::new("initMin"); + static INIT_MIN: java::Field = java::Field::new("initMin"); Millis::new(INIT_MIN.get(e, self).to_rust(e)) } pub fn init_max(&self, e: &mut java::Env) -> Millis { - static INIT_MAX: java::Field = java::Field::new("initMax"); + static INIT_MAX: java::Field = java::Field::new("initMax"); Millis::new(INIT_MAX.get(e, self).to_rust(e)) } } @@ -58,12 +58,12 @@ impl RetryStrategyDelay { } pub fn min(&self, e: &mut java::Env) -> Millis { - static MIN: java::Field = java::Field::new("min"); + static MIN: java::Field = java::Field::new("min"); Millis::new(MIN.get(e, self).to_rust(e)) } pub fn max(&self, e: &mut java::Env) -> Millis { - static MAX: java::Field = java::Field::new("max"); + static MAX: java::Field = java::Field::new("max"); Millis::new(MAX.get(e, self).to_rust(e)) } } diff --git a/glue/src/e2e.rs b/glue/src/e2e.rs index fac9a83..fa1de40 100644 --- a/glue/src/e2e.rs +++ b/glue/src/e2e.rs @@ -6,13 +6,11 @@ use toad_jni::java::{self, Object, Signature}; use toad_msg::alloc::Message; use toad_msg::{Code, Id, Token, Type}; -use crate::message_type::MessageType; -use crate::runtime::Runtime; -use crate::runtime_config::RuntimeConfig; +use crate::{dev, Runtime}; #[non_exhaustive] struct State { - pub runtime: Runtime, + pub runtime: dev::toad::Toad, pub env: java::Env<'static>, pub client: crate::Runtime, pub srv_addr: SocketAddr, @@ -22,12 +20,12 @@ fn init() -> State { let mut _env = crate::test::init(); let env = &mut _env; - let cfg = RuntimeConfig::new(env, - Config::default(), - std::net::SocketAddr::new(std::net::Ipv4Addr::UNSPECIFIED.into(), - 5683)); - let runtime = Runtime::new(env, cfg); - let client = crate::Runtime::try_new("0.0.0.0:5684", Default::default()).unwrap(); + let cfg = + dev::toad::Config::new(env, + Config::default(), + std::net::SocketAddr::new(std::net::Ipv4Addr::UNSPECIFIED.into(), 5683)); + let runtime = dev::toad::Toad::new(env, cfg); + let client = Runtime::try_new("0.0.0.0:5684", Default::default()).unwrap(); State { runtime, env: _env, @@ -60,7 +58,7 @@ fn message_ref_should_throw_when_used_after_close(State {runtime, env, client, s let req_o = req.downcast(env); env.call_method(req_o.as_local(), "type", - Signature::of:: MessageType>(), + Signature::of:: dev::toad::msg::Type>(), &[]) .ok(); diff --git a/glue/src/lib.rs b/glue/src/lib.rs index 0f01c4b..9b338b5 100644 --- a/glue/src/lib.rs +++ b/glue/src/lib.rs @@ -5,8 +5,8 @@ use std::ffi::c_void; use jni::JavaVM; use mem::SharedMemoryRegion; -pub type Runtime = - toad::std::Platform>; +pub type Runtime = ::toad::std::Platform<::toad::std::dtls::N, + ::toad::step::runtime::std::Runtime<::toad::std::dtls::N>>; #[macro_export] macro_rules! package { @@ -15,16 +15,8 @@ macro_rules! package { (ext $start:ident.$($thing:ident).+) => {concat!(stringify!($start), $("/", stringify!($thing)),+)}; } +pub mod dev; pub mod mem; -pub mod message_code; -pub mod message_opt_ref; -pub mod message_opt_value_ref; -pub mod message_ref; -pub mod message_type; -pub mod retry_strategy; -pub mod runtime; -pub mod runtime_config; -pub mod uint; #[no_mangle] pub extern "system" fn JNI_OnLoad(jvm: JavaVM, _: *const c_void) -> i32 { @@ -51,8 +43,7 @@ pub mod test { use toad::time::Millis; use toad_jni::java; - use crate::retry_strategy::RetryStrategy; - use crate::runtime_config::RuntimeConfig; + use crate::dev; pub fn init<'a>() -> java::Env<'a> { static INIT: Once = Once::new(); @@ -82,9 +73,9 @@ pub mod test { let mut e = init(); let e = &mut e; - let r = RuntimeConfig::new(e, - Config::default(), - SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), 5683)); + let r = dev::toad::Config::new(e, + Config::default(), + SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), 5683)); assert_eq!(r.to_toad(e), Config::default()); } @@ -95,24 +86,23 @@ pub mod test { let r = Strategy::Exponential { init_min: Millis::new(0), init_max: Millis::new(100) }; - assert_eq!(RetryStrategy::from_toad(e, r).to_toad(e), r); + assert_eq!(dev::toad::RetryStrategy::from_toad(e, r).to_toad(e), r); let r = Strategy::Delay { min: Millis::new(0), max: Millis::new(100) }; - assert_eq!(RetryStrategy::from_toad(e, r).to_toad(e), r); + assert_eq!(dev::toad::RetryStrategy::from_toad(e, r).to_toad(e), r); } #[test] fn uint() { - use crate::uint; - let mut e = init(); let e = &mut e; macro_rules! case { ($u:ident) => {{ - assert_eq!(uint::$u::from_rust(e, $u::MAX).to_rust(e), $u::MAX); - assert_eq!(uint::$u::from_rust(e, 0).to_rust(e), 0); + assert_eq!(dev::toad::ffi::$u::from_rust(e, $u::MAX).to_rust(e), + $u::MAX); + assert_eq!(dev::toad::ffi::$u::from_rust(e, 0).to_rust(e), 0); }}; } diff --git a/glue/src/message_code.rs b/glue/src/message_code.rs deleted file mode 100644 index 5dff7a0..0000000 --- a/glue/src/message_code.rs +++ /dev/null @@ -1,16 +0,0 @@ -use toad_jni::java; -use toad_msg::Code; - -pub struct MessageCode(java::lang::Object); - -java::object_newtype!(MessageCode); -impl java::Class for MessageCode { - const PATH: &'static str = package!(dev.toad.msg.MessageCode); -} - -impl MessageCode { - pub fn new(e: &mut java::Env, code: Code) -> Self { - static CTOR: java::Constructor = java::Constructor::new(); - CTOR.invoke(e, code.class.into(), code.detail.into()) - } -} diff --git a/glue/src/message_opt_ref.rs b/glue/src/message_opt_ref.rs deleted file mode 100644 index 21a5ee2..0000000 --- a/glue/src/message_opt_ref.rs +++ /dev/null @@ -1,57 +0,0 @@ -use jni::objects::{JClass, JObject}; -use jni::sys::jobject; -use jni::JNIEnv; -use toad_jni::java::{self, Object}; -use toad_msg::{OptNumber, OptValue}; - -use crate::mem::SharedMemoryRegion; -use crate::message_opt_value_ref::MessageOptValueRef; - -pub struct MessageOptRef(pub java::lang::Object); - -java::object_newtype!(MessageOptRef); - -impl java::Class for MessageOptRef { - const PATH: &'static str = package!(dev.toad.msg.MessageOptionRef); -} - -impl MessageOptRef { - pub fn new(env: &mut java::Env, addr: i64, num: i64) -> Self { - static CTOR: java::Constructor = java::Constructor::new(); - CTOR.invoke(env, addr, num) - } - - pub fn number(&self, env: &mut java::Env) -> OptNumber { - static NUMBER: java::Field = java::Field::new("number"); - OptNumber(NUMBER.get(env, self) as u32) - } - - pub unsafe fn values_ptr<'a>(addr: i64) -> &'a mut Vec>> { - crate::mem::Shared::deref::>>>(/* TODO */ 0, addr).as_mut() - .unwrap() - } -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageOptionRef_number<'local>(mut env: JNIEnv<'local>, - o: JObject<'local>, - p: i64) - -> i64 { - java::lang::Object::from_local(&mut env, o).upcast_to::(&mut env) - .number(&mut env) - .0 as i64 -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageOptionRef_values<'local>(mut e: JNIEnv<'local>, - _: JClass<'local>, - p: i64) - -> jobject { - let o = &unsafe { MessageOptRef::values_ptr(p) }; - - let refs = o.iter() - .map(|v| MessageOptValueRef::new(&mut e, (&v.0 as *const Vec).addr() as i64)) - .collect::>(); - - refs.yield_to_java(&mut e) -} diff --git a/glue/src/message_opt_value_ref.rs b/glue/src/message_opt_value_ref.rs deleted file mode 100644 index 5636f03..0000000 --- a/glue/src/message_opt_value_ref.rs +++ /dev/null @@ -1,34 +0,0 @@ -use jni::objects::JClass; -use jni::sys::jobject; -use toad_jni::java; -use toad_msg::OptValue; - -use crate::mem::SharedMemoryRegion; - -pub struct MessageOptValueRef(java::lang::Object); - -java::object_newtype!(MessageOptValueRef); -impl java::Class for MessageOptValueRef { - const PATH: &'static str = package!(dev.toad.msg.MessageOptionValueRef); -} - -impl MessageOptValueRef { - pub fn new(env: &mut java::Env, addr: i64) -> Self { - static CTOR: java::Constructor = java::Constructor::new(); - CTOR.invoke(env, addr) - } - - pub unsafe fn ptr<'a>(addr: i64) -> &'a mut OptValue> { - crate::mem::Shared::deref::>>(/* TODO */ 0, addr).as_mut() - .unwrap() - } -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageOptionValueRef_bytes<'local>(mut env: java::Env<'local>, - _: JClass<'local>, - p: i64) - -> jobject { - let val = unsafe { MessageOptValueRef::ptr(p) }; - env.byte_array_from_slice(val.as_bytes()).unwrap().as_raw() -} diff --git a/glue/src/message_ref.rs b/glue/src/message_ref.rs deleted file mode 100644 index c846c5b..0000000 --- a/glue/src/message_ref.rs +++ /dev/null @@ -1,100 +0,0 @@ -use jni::objects::JClass; -use jni::sys::jobject; -use toad_jni::java::{self, Object}; -use toad_msg::alloc::Message; -use toad_msg::Type; - -use crate::mem::{Shared, SharedMemoryRegion}; -use crate::message_code::MessageCode; -use crate::message_opt_ref::MessageOptRef; -use crate::message_type::MessageType; - -pub struct MessageRef(java::lang::Object); - -java::object_newtype!(MessageRef); -impl java::Class for MessageRef { - const PATH: &'static str = package!(dev.toad.msg.MessageRef); -} - -impl MessageRef { - pub fn new(env: &mut java::Env, message: Message) -> Self { - let ptr = unsafe { Shared::alloc_message(message) }; - static CTOR: java::Constructor = java::Constructor::new(); - CTOR.invoke(env, ptr.addr() as i64) - } - - pub fn close(&self, env: &mut java::Env) { - static CLOSE: java::Method = java::Method::new("close"); - CLOSE.invoke(env, self) - } - - pub fn ty(&self, env: &mut java::Env) -> Type { - static TYPE: java::Method MessageType> = java::Method::new("type"); - TYPE.invoke(env, self).to_toad(env) - } - - pub unsafe fn ptr<'a>(addr: i64) -> &'a mut Message { - crate::mem::Shared::deref::(/* TODO */ 0, addr).as_mut() - .unwrap() - } -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageRef_id<'local>(mut env: java::Env<'local>, - _: JClass<'local>, - addr: i64) - -> i32 { - let msg = unsafe { MessageRef::ptr(addr) }; - msg.id.0 as i32 -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageRef_token<'local>(mut env: java::Env<'local>, - _: JClass<'local>, - addr: i64) - -> jobject { - let msg = unsafe { MessageRef::ptr(addr) }; - env.byte_array_from_slice(&msg.token.0).unwrap().as_raw() -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageRef_payload<'local>(mut env: java::Env<'local>, - _: JClass<'local>, - addr: i64) - -> jobject { - let msg = unsafe { MessageRef::ptr(addr) }; - env.byte_array_from_slice(&msg.payload.0).unwrap().as_raw() -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageRef_type<'local>(mut e: java::Env<'local>, - _: JClass<'local>, - addr: i64) - -> jobject { - let msg = unsafe { MessageRef::ptr(addr) }; - MessageType::new(&mut e, msg.ty).yield_to_java(&mut e) -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageRef_code<'local>(mut e: java::Env<'local>, - _: JClass<'local>, - addr: i64) - -> jobject { - let msg = unsafe { MessageRef::ptr(addr) }; - MessageCode::new(&mut e, msg.code).yield_to_java(&mut e) -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_msg_MessageRef_opts<'local>(mut e: java::Env<'local>, - _: JClass<'local>, - addr: i64) - -> jobject { - let msg = unsafe { MessageRef::ptr(addr) }; - let opts = &msg.opts; - - let refs = opts.into_iter() - .map(|(n, v)| MessageOptRef::new(&mut e, v as *const _ as i64, n.0.into())) - .collect::>(); - - refs.yield_to_java(&mut e) -} diff --git a/glue/src/message_type.rs b/glue/src/message_type.rs deleted file mode 100644 index 8708abb..0000000 --- a/glue/src/message_type.rs +++ /dev/null @@ -1,37 +0,0 @@ -use toad_jni::java; -use toad_msg::Type; - -pub struct MessageType(java::lang::Object); - -java::object_newtype!(MessageType); -impl java::Class for MessageType { - const PATH: &'static str = package!(dev.toad.msg.MessageType); -} - -impl MessageType { - pub fn new(env: &mut java::Env, ty: Type) -> Self { - static FROM_STRING: java::StaticMethod MessageType> = - java::StaticMethod::new("fromString"); - - let str = match ty { - | Type::Con => "CON", - | Type::Non => "NON", - | Type::Ack => "ACK", - | Type::Reset => "RESET", - }; - - FROM_STRING.invoke(env, str.to_string()) - } - - pub fn to_toad(&self, env: &mut java::Env) -> Type { - static TO_STRING: java::Method String> = java::Method::new("toString"); - - match TO_STRING.invoke(env, self).trim().to_uppercase().as_str() { - | "CON" => Type::Con, - | "NON" => Type::Non, - | "ACK" => Type::Ack, - | "RESET" => Type::Reset, - | o => panic!("malformed message type {}", o), - } - } -} diff --git a/glue/src/runtime.rs b/glue/src/runtime.rs deleted file mode 100644 index af9c0e8..0000000 --- a/glue/src/runtime.rs +++ /dev/null @@ -1,78 +0,0 @@ -use jni::objects::{JClass, JObject}; -use jni::sys::jobject; -use toad::platform::Platform; -use toad_jni::java::{self, Object}; - -use crate::mem::{Shared, SharedMemoryRegion}; -use crate::message_ref::MessageRef; -use crate::runtime_config::RuntimeConfig; -use crate::Runtime as ToadRuntime; - -pub struct Runtime(java::lang::Object); - -impl Runtime { - pub fn new(e: &mut java::Env, cfg: RuntimeConfig) -> Self { - static CTOR: java::Constructor = java::Constructor::new(); - CTOR.invoke(e, cfg) - } - - pub fn poll_req(&self, e: &mut java::Env) -> Option { - static POLL_REQ: java::Method java::util::Optional> = - java::Method::new("pollReq"); - POLL_REQ.invoke(e, self).to_option(e) - } - - pub fn config(&self, e: &mut java::Env) -> RuntimeConfig { - static CONFIG: java::Method RuntimeConfig> = java::Method::new("config"); - CONFIG.invoke(e, self) - } - - fn init_impl(e: &mut java::Env, cfg: RuntimeConfig) -> i64 { - let r = || ToadRuntime::try_new(cfg.addr(e), cfg.to_toad(e)).unwrap(); - unsafe { crate::mem::Shared::init(r).addr() as i64 } - } - - fn poll_req_impl(e: &mut java::Env, addr: i64) -> java::util::Optional { - match unsafe { - Shared::deref::(/* TODO */ 0, addr).as_ref() - .unwrap() - }.poll_req() - { - | Ok(req) => { - let mr = MessageRef::new(e, req.unwrap().into()); - java::util::Optional::::of(e, mr) - }, - | Err(nb::Error::WouldBlock) => java::util::Optional::::empty(e), - | Err(nb::Error::Other(err)) => { - e.throw(format!("{:?}", err)).unwrap(); - java::util::Optional::::empty(e) - }, - } - } -} - -java::object_newtype!(Runtime); - -impl java::Class for Runtime { - const PATH: &'static str = package!(dev.toad.ToadRuntime); -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_ToadRuntime_init<'local>(mut e: java::Env<'local>, - _: JClass<'local>, - cfg: JObject<'local>) - -> i64 { - let e = &mut e; - let cfg = java::lang::Object::from_local(e, cfg).upcast_to::(e); - - Runtime::init_impl(e, cfg) -} - -#[no_mangle] -pub extern "system" fn Java_dev_toad_ToadRuntime_pollReq<'local>(mut e: java::Env<'local>, - _: JClass<'local>, - addr: i64) - -> jobject { - let e = &mut e; - Runtime::poll_req_impl(e, addr).yield_to_java(e) -} diff --git a/src/main/java/dev.toad/Client.java b/src/main/java/dev.toad/Client.java new file mode 100644 index 0000000..4efa0f1 --- /dev/null +++ b/src/main/java/dev.toad/Client.java @@ -0,0 +1,10 @@ +package dev.toad; + +public final class Client { + + final Toad toad; + + Client(Toad toad) { + this.toad = toad; + } +} diff --git a/src/main/java/dev.toad/ToadRuntime.java b/src/main/java/dev.toad/Toad.java similarity index 85% rename from src/main/java/dev.toad/ToadRuntime.java rename to src/main/java/dev.toad/Toad.java index 6590cce..1e38ff7 100644 --- a/src/main/java/dev.toad/ToadRuntime.java +++ b/src/main/java/dev.toad/Toad.java @@ -1,46 +1,58 @@ package dev.toad; import dev.toad.ffi.*; -import dev.toad.msg.MessageRef; import java.net.InetSocketAddress; import java.time.Duration; import java.util.Optional; import java.util.function.Function; -public class ToadRuntime { +public final class Toad { static native Config defaultConfigImpl(); static Config defaultConfig = null; static Config defaultConfig() { - if (ToadRuntime.defaultConfig == null) { - ToadRuntime.defaultConfig = ToadRuntime.defaultConfigImpl(); + if (Toad.defaultConfig == null) { + Toad.defaultConfig = Toad.defaultConfigImpl(); } - return ToadRuntime.defaultConfig; + return Toad.defaultConfig; } static { System.loadLibrary("toad_java_glue"); } - private final Ptr ptr; - private final Config config; + final Ptr ptr; + final Config config; - private static native long init(Config o); + static native long init(Config o); - private static native Optional pollReq(long addr); + static native Optional pollReq(long ptr); - Optional pollReq() { - return ToadRuntime.pollReq(this.ptr.addr()); + static native Optional pollResp( + long ptr, + dev.toad.msg.Token t, + InetSocketAddress n + ); + + Optional pollReq() { + return Toad.pollReq(this.ptr.addr()); + } + + Optional pollResp( + dev.toad.msg.Token regarding, + InetSocketAddress from + ) { + return Toad.pollResp(this.ptr.addr(), regarding, from); } public static BuilderRequiresBindToAddress builder() { return new Builder(); } - ToadRuntime(Config o) { + Toad(Config o) { this.config = o; this.ptr = Ptr.register(this.getClass(), this.init(o)); } @@ -50,21 +62,21 @@ public class ToadRuntime { } public interface BuilderRequiresBindToAddress { - ToadRuntime.Builder port(short port); - ToadRuntime.Builder address(InetSocketAddress addr); + Toad.Builder port(short port); + Toad.Builder address(InetSocketAddress addr); } public static final class Builder implements BuilderRequiresBindToAddress { Config.Msg.Builder msg = Config.Msg.builder(); Optional addr = Optional.empty(); - u8 concurrency = ToadRuntime.defaultConfig().concurrency; + u8 concurrency = Toad.defaultConfig().concurrency; Builder() {} - public ToadRuntime build() { + public Toad build() { var cfg = new Config(this.addr.get(), this.concurrency, this.msg.build()); - return new ToadRuntime(cfg); + return new Toad(cfg); } public Builder msg(Function f) { @@ -183,10 +195,10 @@ public class ToadRuntime { Con.Builder con = Con.builder(); Non.Builder non = Non.builder(); - u16 tokenSeed = ToadRuntime.defaultConfig().msg.tokenSeed; - u16 probingRateBytesPerSecond = ToadRuntime.defaultConfig() + u16 tokenSeed = Toad.defaultConfig().msg.tokenSeed; + u16 probingRateBytesPerSecond = Toad.defaultConfig() .msg.probingRateBytesPerSecond; - Duration multicastResponseLeisure = ToadRuntime.defaultConfig() + Duration multicastResponseLeisure = Toad.defaultConfig() .msg.multicastResponseLeisure; public Msg build() { @@ -275,11 +287,11 @@ public class ToadRuntime { public static final class Builder { - RetryStrategy ackedRetryStrategy = ToadRuntime.defaultConfig() + RetryStrategy ackedRetryStrategy = Toad.defaultConfig() .msg.con.ackedRetryStrategy; - RetryStrategy unackedRetryStrategy = ToadRuntime.defaultConfig() + RetryStrategy unackedRetryStrategy = Toad.defaultConfig() .msg.con.unackedRetryStrategy; - u16 maxAttempts = ToadRuntime.defaultConfig().msg.con.maxAttempts; + u16 maxAttempts = Toad.defaultConfig().msg.con.maxAttempts; public Con build() { return new Con( @@ -343,9 +355,9 @@ public class ToadRuntime { public static final class Builder { - RetryStrategy retryStrategy = ToadRuntime.defaultConfig() + RetryStrategy retryStrategy = Toad.defaultConfig() .msg.non.retryStrategy; - u16 maxAttempts = ToadRuntime.defaultConfig().msg.non.maxAttempts; + u16 maxAttempts = Toad.defaultConfig().msg.non.maxAttempts; public Non build() { return new Non(this.retryStrategy, this.maxAttempts); diff --git a/src/main/java/dev.toad/msg/MessageCode.java b/src/main/java/dev.toad/msg/Code.java similarity index 91% rename from src/main/java/dev.toad/msg/MessageCode.java rename to src/main/java/dev.toad/msg/Code.java index 75b9854..4b99b21 100644 --- a/src/main/java/dev.toad/msg/MessageCode.java +++ b/src/main/java/dev.toad/msg/Code.java @@ -1,11 +1,11 @@ package dev.toad.msg; -public class MessageCode { +public class Code { private final int clazz; private final int detail; - public MessageCode(int clazz, int detail) { + public Code(int clazz, int detail) { this.clazz = clazz; this.detail = detail; } diff --git a/src/main/java/dev.toad/msg/Id.java b/src/main/java/dev.toad/msg/Id.java new file mode 100644 index 0000000..e0482ad --- /dev/null +++ b/src/main/java/dev.toad/msg/Id.java @@ -0,0 +1,14 @@ +package dev.toad.msg; + +public final class Id { + + final int id; + + public Id(int id) { + this.id = id; + } + + public int toInt() { + return this.id; + } +} diff --git a/src/main/java/dev.toad/msg/Message.java b/src/main/java/dev.toad/msg/Message.java index 732aa9a..9bae185 100644 --- a/src/main/java/dev.toad/msg/Message.java +++ b/src/main/java/dev.toad/msg/Message.java @@ -6,15 +6,15 @@ import java.util.List; public interface Message { public InetSocketAddress source(); - public int id(); + public Id id(); - public byte[] token(); + public Token token(); - public MessageCode code(); + public Code code(); - public MessageType type(); + public Type type(); - public List options(); + public List