Remove Buffers type

atat/src/lib.rs

@@ -222,7 +222,6 @@
 // This mod MUST go first, so that the others see its macros.
 pub(crate) mod fmt;
 
-mod buffers;
 mod config;
 pub mod digest;
 mod error;
@@ -261,7 +260,6 @@ pub use serde_at;
 #[cfg(feature = "derive")]
 pub use heapless;
 
-pub use buffers::Buffers;
 pub use config::Config;
 pub use digest::{AtDigester, AtDigester as DefaultDigester, DigestResult, Digester, Parser};
 pub use error::{CmeError, CmsError, ConnectionError, Error, InternalError};

atat_derive/src/helpers.rs

@@ -52,7 +52,7 @@ pub fn add_type_parameter_bound(
     let where_type = syn::PredicateType {
         bounded_ty: parse_quote!(#ident),
         colon_token: <syn::Token![:]>::default(),
-        bounds: vec![trait_bound].iter().cloned().collect(),
+        bounds: [trait_bound].iter().cloned().collect(),
         lifetimes: None,
     };
     generics

examples/src/bin/embassy.rs

@@ -3,7 +3,10 @@
 #![feature(type_alias_impl_trait)]
 #![allow(incomplete_features)]
 
-use atat::{asynch::AtatClient, AtatIngress, Buffers, DefaultDigester, Ingress};
+use atat::{
+    asynch::{AtatClient, Client},
+    AtatIngress, DefaultDigester, Ingress, ResponseChannel, UrcChannel,
+};
 use atat_examples::common;
 use embassy_executor::Spawner;
 use embassy_executor::_export::StaticCell;
@@ -47,14 +50,14 @@ async fn main(spawner: Spawner) {
     );
     let (reader, writer) = uart.split();
 
-    static BUFFERS: Buffers<common::Urc, INGRESS_BUF_SIZE, URC_CAPACITY, URC_SUBSCRIBERS> =
-        Buffers::<common::Urc, INGRESS_BUF_SIZE, URC_CAPACITY, URC_SUBSCRIBERS>::new();
-
-    let (ingress, mut client) = BUFFERS.split(
-        writer,
+    static RES_CHANNEL: ResponseChannel<INGRESS_BUF_SIZE> = ResponseChannel::new();
+    static URC_CHANNEL: UrcChannel<Urc, URC_CAPACITY, URC_SUBSCRIBERS> = UrcChannel::new();
+    let ingress = Ingress::new(
         DefaultDigester::<common::Urc>::default(),
-        atat::Config::default(),
+        RES_CHANNEL.publisher(),
+        URC_CHANNEL.publisher(),
     );
+    let mut client = Client::new(writer, RES_CHANNEL.subscriber(), atat::Config::default());
 
     spawner.spawn(ingress_task(ingress, reader)).unwrap();
 

examples/src/bin/std-tokio.rs

@@ -1,11 +1,13 @@
 #![feature(async_fn_in_trait)]
 #![allow(incomplete_features)]
 use atat_examples::common;
 
-use std::process::exit;
-
-use atat::{asynch::AtatClient, AtatIngress, Buffers, Config, DefaultDigester, Ingress};
+use atat::{
+    asynch::{AtatClient, Client},
+    AtatIngress, Config, DefaultDigester, Ingress, ResponseChannel, UrcChannel,
+};
 use embedded_io_adapters::tokio_1::FromTokio;
+use std::process::exit;
 use tokio_serial::SerialStream;
 
 const INGRESS_BUF_SIZE: usize = 1024;
@@ -16,16 +18,16 @@
 async fn main() -> ! {
     env_logger::init();
 
-    static BUFFERS: Buffers<common::Urc, INGRESS_BUF_SIZE, URC_CAPACITY, URC_SUBSCRIBERS> =
-        Buffers::<common::Urc, INGRESS_BUF_SIZE, URC_CAPACITY, URC_SUBSCRIBERS>::new();
-
     let (reader, writer) = SerialStream::pair().expect("Failed to create serial pair");
 
-    let (ingress, mut client) = BUFFERS.split(
-        FromTokio::new(writer),
+    static RES_CHANNEL: ResponseChannel<INGRESS_BUF_SIZE> = ResponseChannel::new();
+    static URC_CHANNEL: UrcChannel<common::Urc, URC_CAPACITY, URC_SUBSCRIBERS> = UrcChannel::new();
+    let ingress = Ingress::new(
         DefaultDigester::<common::Urc>::default(),
-        Config::default(),
+        RES_CHANNEL.publisher().unwrap(),
+        URC_CHANNEL.publisher(),
     );
+    let mut client = Client::new(FromTokio::new(writer), &RES_CHANNEL, Config::default());
 
     tokio::spawn(ingress_task(ingress, FromTokio::new(reader)));
 

serde_at/src/de/mod.rs

@@ -176,16 +176,14 @@ impl<'a> Deserializer<'a> {
             if self.is_trailing_parsing {
                 self.index = self.slice.len();
                 return Ok(&self.slice[start..]);
-            } else {
-                if let Some(c) = self.peek() {
-                    if (c as char).is_alphanumeric() || (c as char).is_whitespace() {
-                        self.eat_char();
-                    } else {
-                        return Err(Error::EofWhileParsingString);
-                    }
+            } else if let Some(c) = self.peek() {
+                if (c as char).is_alphanumeric() || (c as char).is_whitespace() {
+                    self.eat_char();
                 } else {
-                    return Ok(&self.slice[start..self.index]);
+                    return Err(Error::EofWhileParsingString);
                 }
+            } else {
+                return Ok(&self.slice[start..self.index]);
             }
         }
     }