Implement BacklogManager

3 files changed, 113 insertions, 59 deletions

diff --git a/src/message/signalproxy/objects/backlogmanager.rs b/src/message/signalproxy/objects/backlogmanager.rs
index bcdd0b7..93d065d 100644
--- a/src/message/signalproxy/objects/backlogmanager.rs
+++ b/src/message/signalproxy/objects/backlogmanager.rs
@@ -51,107 +51,157 @@
 #![allow(unused_variables, unused_imports)]
 #![allow(non_snake_case, dead_code)]
 
-use crate::primitive::VariantList;
+use libquassel_derive::{sync, NetworkMap};
+
+use crate::message::{Class, StatefulSyncableClient, Syncable};
+use crate::primitive::{BufferId, MessageType, MsgId, VariantList};
 
 /// Receive and Request Backlog
 /// All "request" functions are Client to Server and all "receive" functions are Server to Client
-#[derive(Clone, Debug, std::cmp::PartialEq, Default)]
+#[derive(Clone, Debug, std::cmp::PartialEq, Default, NetworkMap)]
 pub struct BacklogManager {}
 
+#[allow(non_snake_case)]
 impl BacklogManager {
     /// Loads backlog for `bufferId`, starting at message `first`, up to `last`
     /// (plus `additional` more messages after `last`) but at most `limit`
     /// messages total.
-    fn requestBacklog(self: Self, buffer_id: u32, first: u32, last: u32, limit: u32, additional: u32) {
-        unimplemented!()
+    pub fn requestBacklog(
+        &self,
+        buffer_id: BufferId,
+        first: MsgId,
+        last: MsgId,
+        limit: i32,
+        additional: i32,
+    ) {
+        sync!(
+            "requestBacklog",
+            [buffer_id, first, last, limit, additional]
+        );
     }
 
     /// Same as `requestBacklog`, but only messages of a certain message `type`
     /// with certain `flags` set.
-    fn requestBacklogFiltered(
-        self: Self,
-        buffer_id: u32,
-        first: u32,
-        last: u32,
-        limit: u32,
-        additional: u32,
-        msgtype: u32,
-        flags: u32,
+    pub fn requestBacklogFiltered(
+        &self,
+        buffer_id: BufferId,
+        first: MsgId,
+        last: MsgId,
+        limit: i32,
+        additional: i32,
+        msgtype: MessageType,
+        flags: i32,
     ) {
-        unimplemented!()
+        sync!(
+            "requestBacklogFiltered",
+            [
+                buffer_id,
+                first,
+                last,
+                limit,
+                additional,
+                msgtype.bits(),
+                flags
+            ]
+        );
     }
 
     /// Same as `requestBacklog`, but applied to all buffers.
-    fn requestBacklogAll(self: Self, first: u32, last: u32, limit: u32, additional: u32) {
-        unimplemented!()
+    pub fn requestBacklogAll(&self, first: MsgId, last: MsgId, limit: i32, additional: i32) {
+        sync!("requestBacklogAll", [first, last, limit, additional]);
     }
 
     /// Same as `requestBacklogFiltered`, but applied to all buffers.
-    fn requestBacklogAllFiltered(
-        self: Self,
-        first: u32,
-        last: u32,
-        limit: u32,
-        additional: u32,
-        msgtype: u32,
-        flags: u32,
+    pub fn requestBacklogAllFiltered(
+        &self,
+        first: MsgId,
+        last: MsgId,
+        limit: i32,
+        additional: i32,
+        msgtype: MessageType,
+        flags: i32,
     ) {
-        unimplemented!()
+        sync!(
+            "requestBacklogAllFiltered",
+            [first, last, limit, additional, msgtype.bits(), flags]
+        );
     }
 
     /// The response to `requestBacklog`, with the messages encoded as Variants
     /// in the `messages` parameter.
-    fn receiveBacklog(
-        self: Self,
-        buffer_id: u32,
-        first: u32,
-        last: u32,
-        limit: u32,
-        additional: u32,
+    pub fn receiveBacklog(
+        &self,
+        buffer_id: BufferId,
+        first: MsgId,
+        last: MsgId,
+        limit: i32,
+        additional: i32,
         messages: VariantList,
     ) {
-        unimplemented!()
+        sync!(
+            "receiveBacklog",
+            [buffer_id, first, last, limit, additional, messages]
+        );
     }
 
     /// The response to `requestBacklogFiltered`, with the messages encoded as
     /// Variants in the `messages` parameter.
-    fn receiveBacklogFiltered(
-        self: Self,
-        buffer_id: u32,
-        first: u32,
-        last: u32,
-        limit: u32,
-        additional: u32,
-        msgtype: u32,
-        flags: u32,
+    pub fn receiveBacklogFiltered(
+        &self,
+        buffer_id: BufferId,
+        first: MsgId,
+        last: MsgId,
+        limit: i32,
+        additional: i32,
+        msgtype: MessageType,
+        flags: i32,
         messages: VariantList,
     ) {
-        unimplemented!()
+        sync!(
+            "receiveBacklogFiltered",
+            [buffer_id, first, last, limit, additional, msgtype.bits(), flags, messages]
+        );
     }
 
     /// Same as `receiveBacklog`, but applied to all buffers.
-    fn receiveBacklogAll(
-        self: Self,
-        first: u32,
-        last: u32,
-        limit: u32,
-        additional: u32,
+    pub fn receiveBacklogAll(
+        &self,
+        first: MsgId,
+        last: MsgId,
+        limit: i32,
+        additional: i32,
         messages: VariantList,
     ) {
-        unimplemented!()
+        sync!(
+            "receiveBacklogAll",
+            [first, last, limit, additional, messages]
+        );
     }
 
     /// Same as `receiveBacklogFiltered`, but applied to all buffers.
-    fn receiveBacklogAllFiltered(
-        self: Self,
-        first: u32,
-        last: u32,
-        limit: u32,
-        additional: u32,
-        msgtype: u32,
-        flags: u32,
+    pub fn receiveBacklogAllFiltered(
+        &self,
+        first: MsgId,
+        last: MsgId,
+        limit: i32,
+        additional: i32,
+        msgtype: MessageType,
+        flags: i32,
         messages: VariantList,
     ) {
-        unimplemented!()
+        sync!(
+            "receiveBacklogAllFiltered",
+            [first, last, limit, additional, msgtype.bits(), flags, messages]
+        );
     }
 }
+
+#[cfg(feature = "client")]
+impl StatefulSyncableClient for BacklogManager {}
+
+#[cfg(feature = "server")]
+impl StatefulSyncableServer for BacklogManager {}
+
+impl Syncable for BacklogManager {
+    const CLASS: Class = Class::BacklogManager;
+}
diff --git a/src/message/signalproxy/syncmessage.rs b/src/message/signalproxy/syncmessage.rs
index d1f359b..b1123ac 100644
--- a/src/message/signalproxy/syncmessage.rs
+++ b/src/message/signalproxy/syncmessage.rs
@@ -6,6 +6,7 @@ use crate::{deserialize::Deserialize, serialize::Serialize};
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub enum Class {
     AliasManager,
+    BacklogManager,
     BufferSyncer,
     BufferViewConfig,
     BufferViewManager,
@@ -33,6 +34,7 @@ impl From<&str> for Class {
     fn from(class: &str) -> Self {
         match class {
             "AliasManager" => Self::AliasManager,
+            "BacklogManager" => Class::BacklogManager,
             "BufferSyncer" => Self::BufferSyncer,
             "BufferViewConfig" => Self::BufferViewConfig,
             "BufferViewManager" => Self::BufferViewManager,
@@ -56,6 +58,7 @@ impl Class {
     pub fn as_str(&self) -> &str {
         match self {
             Class::AliasManager => "AliasManager",
+            Class::BacklogManager => "BacklogManager",
             Class::BufferSyncer => "BufferSyncer",
             Class::BufferViewConfig => "BufferViewConfig",
             Class::BufferViewManager => "BufferViewManager",
diff --git a/src/session/mod.rs b/src/session/mod.rs
index 9f24da6..392e6e1 100644
--- a/src/session/mod.rs
+++ b/src/session/mod.rs
@@ -51,6 +51,7 @@ pub trait SessionManager {
     {
         match msg.class_name {
             Class::AliasManager => self.alias_manager().sync(msg),
+            Class::BacklogManager => self.backlog_manager().sync(msg),
             Class::BufferSyncer => self.buffer_syncer().sync(msg),
             Class::BufferViewConfig => (),
             Class::BufferViewManager => self.buffer_view_manager().sync(msg),