Add bulk MXAccess subscription commands

2026-04-26 22:29:27 -04:00
parent daff16cfd2
commit 3d11ac3316
31 changed files with 14346 additions and 969 deletions
@@ -3,9 +3,11 @@ use crate::error::Error;
 use crate::generated::mxaccess_gateway::v1::mx_command::Payload;
 use crate::generated::mxaccess_gateway::v1::mx_command_reply;
 use crate::generated::mxaccess_gateway::v1::{
-    AddItem2Command, AddItemCommand, AdviseCommand, CloseSessionRequest, MxCommand, MxCommandKind,
-    MxCommandReply, MxCommandRequest, MxValue as ProtoMxValue, OpenSessionRequest, RegisterCommand,
-    StreamEventsRequest, Write2Command, WriteCommand,
+    AddItem2Command, AddItemBulkCommand, AddItemCommand, AdviseCommand, AdviseItemBulkCommand,
+    CloseSessionRequest, MxCommand, MxCommandKind, MxCommandReply, MxCommandRequest,
+    MxValue as ProtoMxValue, OpenSessionRequest, RegisterCommand, RemoveItemBulkCommand,
+    RemoveItemCommand, StreamEventsRequest, SubscribeBulkCommand, SubscribeResult, UnAdviseCommand,
+    UnAdviseItemBulkCommand, UnsubscribeBulkCommand, Write2Command, WriteCommand,
 };
 use crate::value::MxValue;

@@ -94,6 +96,18 @@ impl Session {
        Ok(add_item2_handle(&reply))
    }

+    pub async fn remove_item(&self, server_handle: i32, item_handle: i32) -> Result<(), Error> {
+        self.invoke(
+            MxCommandKind::RemoveItem,
+            Payload::RemoveItem(RemoveItemCommand {
+                server_handle,
+                item_handle,
+            }),
+        )
+        .await?;
+        Ok(())
+    }
+
    pub async fn advise(&self, server_handle: i32, item_handle: i32) -> Result<(), Error> {
        self.invoke(
            MxCommandKind::Advise,
@@ -106,6 +120,126 @@ impl Session {
        Ok(())
    }

+    pub async fn un_advise(&self, server_handle: i32, item_handle: i32) -> Result<(), Error> {
+        self.invoke(
+            MxCommandKind::UnAdvise,
+            Payload::UnAdvise(UnAdviseCommand {
+                server_handle,
+                item_handle,
+            }),
+        )
+        .await?;
+        Ok(())
+    }
+
+    pub async fn add_item_bulk(
+        &self,
+        server_handle: i32,
+        tag_addresses: Vec<String>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::AddItemBulk,
+                Payload::AddItemBulk(AddItemBulkCommand {
+                    server_handle,
+                    tag_addresses,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::AddItemBulk))
+    }
+
+    pub async fn advise_item_bulk(
+        &self,
+        server_handle: i32,
+        item_handles: Vec<i32>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::AdviseItemBulk,
+                Payload::AdviseItemBulk(AdviseItemBulkCommand {
+                    server_handle,
+                    item_handles,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::AdviseItemBulk))
+    }
+
+    pub async fn remove_item_bulk(
+        &self,
+        server_handle: i32,
+        item_handles: Vec<i32>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::RemoveItemBulk,
+                Payload::RemoveItemBulk(RemoveItemBulkCommand {
+                    server_handle,
+                    item_handles,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::RemoveItemBulk))
+    }
+
+    pub async fn un_advise_item_bulk(
+        &self,
+        server_handle: i32,
+        item_handles: Vec<i32>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::UnAdviseItemBulk,
+                Payload::UnAdviseItemBulk(UnAdviseItemBulkCommand {
+                    server_handle,
+                    item_handles,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::UnAdviseItemBulk))
+    }
+
+    pub async fn subscribe_bulk(
+        &self,
+        server_handle: i32,
+        tag_addresses: Vec<String>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::SubscribeBulk,
+                Payload::SubscribeBulk(SubscribeBulkCommand {
+                    server_handle,
+                    tag_addresses,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::SubscribeBulk))
+    }
+
+    pub async fn unsubscribe_bulk(
+        &self,
+        server_handle: i32,
+        item_handles: Vec<i32>,
+    ) -> Result<Vec<SubscribeResult>, Error> {
+        let reply = self
+            .invoke(
+                MxCommandKind::UnsubscribeBulk,
+                Payload::UnsubscribeBulk(UnsubscribeBulkCommand {
+                    server_handle,
+                    item_handles,
+                }),
+            )
+            .await?;
+
+        Ok(bulk_results(reply, BulkReplyKind::UnsubscribeBulk))
+    }
+
    pub async fn write(
        &self,
        server_handle: i32,
@@ -226,6 +360,41 @@ fn add_item2_handle(reply: &MxCommandReply) -> i32 {
    }
 }

+enum BulkReplyKind {
+    AddItemBulk,
+    AdviseItemBulk,
+    RemoveItemBulk,
+    UnAdviseItemBulk,
+    SubscribeBulk,
+    UnsubscribeBulk,
+}
+
+fn bulk_results(reply: MxCommandReply, kind: BulkReplyKind) -> Vec<SubscribeResult> {
+    match (reply.payload, kind) {
+        (Some(mx_command_reply::Payload::AddItemBulk(reply)), BulkReplyKind::AddItemBulk) => {
+            reply.results
+        }
+        (Some(mx_command_reply::Payload::AdviseItemBulk(reply)), BulkReplyKind::AdviseItemBulk) => {
+            reply.results
+        }
+        (Some(mx_command_reply::Payload::RemoveItemBulk(reply)), BulkReplyKind::RemoveItemBulk) => {
+            reply.results
+        }
+        (
+            Some(mx_command_reply::Payload::UnAdviseItemBulk(reply)),
+            BulkReplyKind::UnAdviseItemBulk,
+        ) => reply.results,
+        (Some(mx_command_reply::Payload::SubscribeBulk(reply)), BulkReplyKind::SubscribeBulk) => {
+            reply.results
+        }
+        (
+            Some(mx_command_reply::Payload::UnsubscribeBulk(reply)),
+            BulkReplyKind::UnsubscribeBulk,
+        ) => reply.results,
+        _ => Vec::new(),
+    }
+}
+
 fn int32_reply_value(value: &ProtoMxValue) -> Option<i32> {
    match value.kind.as_ref()? {
        crate::generated::mxaccess_gateway::v1::mx_value::Kind::Int32Value(value) => Some(*value),