server side preparation

src/net/msg.rs

@@ -1,83 +1,53 @@
-use super::data;
+use super::{RequestMsg, data::*};
 
-#[derive(Debug)]
-pub enum ClientMsg {
-    CreateAccount(CreateAccount),
-    Login(Login),
-    RequestMsgs,
-    SendMsg(SendMsg),
-    RequestUsers(RequestUsers),
-}
-
-#[derive(Debug)]
-pub enum ServerMsg {
-    CreateAccountResp(CreateAccountResp),
-    LoginResp(LoginResp),
-    LoadMsg(LoadMsg),
-    LoadMsgs(Vec<LoadMsg>),
-    ServerError(ServerError),
-    RequestUsersResp(RequestUsersResp),
-}
-
-// TODO: a ton of this should really just be macros :sob:
-
-pub use data::CreateAccountRespV0 as CreateAccountResp;
-pub use data::CreateAccountV0 as CreateAccount;
-pub use data::LoadMsgV0 as LoadMsg;
-pub use data::LoginKeyV0 as LoginKey;
-pub use data::LoginRespV0 as LoginResp;
-pub use data::LoginV0 as Login;
-pub use data::RequestUsersRespV0 as RequestUsersResp;
-pub use data::RequestUsersV0 as RequestUsers;
-pub use data::SendMsgV0 as SendMsg;
-pub use data::ServerErrorV0 as ServerError;
-pub use data::ServerUserV0 as ServerUser;
-pub use data::UserIdV0 as UserId;
-
-impl From<CreateAccount> for ClientMsg {
-    fn from(value: CreateAccount) -> Self {
-        Self::CreateAccount(value)
-    }
-}
-
-impl From<Login> for ClientMsg {
-    fn from(value: Login) -> Self {
-        Self::Login(value)
-    }
-}
-
-impl From<RequestUsers> for ClientMsg {
-    fn from(value: RequestUsers) -> Self {
-        Self::RequestUsers(value)
-    }
-}
-
-impl From<ServerError> for ServerMsg {
-    fn from(value: ServerError) -> Self {
-        Self::ServerError(value)
-    }
-}
-
-impl From<LoadMsg> for ServerMsg {
-    fn from(value: LoadMsg) -> Self {
-        Self::LoadMsg(value)
-    }
-}
-
-impl From<CreateAccountResp> for ServerMsg {
-    fn from(value: CreateAccountResp) -> Self {
-        Self::CreateAccountResp(value)
-    }
-}
-
-impl From<LoginResp> for ServerMsg {
-    fn from(value: LoginResp) -> Self {
-        Self::LoginResp(value)
-    }
-}
-
-impl From<RequestUsersResp> for ServerMsg {
-    fn from(value: RequestUsersResp) -> Self {
-        Self::RequestUsersResp(value)
-    }
+msg_type!(ClientMsg: {
+    0: CreateAccount => CreateAccountResp,
+    1: Login => LoginResp,
+    2: RequestUsers => RequestUsersResp,
+    3: RequestFriends => RequestFriendsResp,
+    4: AddFriend => AddFriendResp,
+    5: RemoveFriend,
+    6: AnswerFriendRequest,
+    7: GenerateToken => GenerateTokenResp,
+});
+msg_type!(ServerMsg: {
+    0: NotLoggedIn,
+    1: NoPermission,
+    2: AccountDeleted,
+    3: CreateAccountResp,
+    4: LoginResp,
+    5: RequestUsersResp,
+    6: RequestFriendsResp,
+    7: AddFriendResp,
+    8: GenerateTokenResp,
+});
+
+macro_rules! msg_type {
+    ($msg:ident: {$($num:literal: $name:ident $(=> $resp:ident)?,)*}) => {
+        #[repr(u32)]
+        #[derive(Debug, bitcode::Encode, bitcode::Decode)]
+        pub enum $msg {$(
+            $name($name) = $num,
+        )*}
+        $(
+            impl From<$name> for $msg {
+                fn from(value: $name) -> Self {
+                    Self::$name(value)
+                }
+            }
+            $(
+            impl RequestMsg for $name {
+                type Result = $resp;
+                fn result(msg: ServerMsg) -> Option<Self::Result> {
+                    if let ServerMsg::$resp(res) = msg {
+                        Some(res)
+                    } else {
+                        None
+                    }
+                }
+            }
+            )?
+        )*
+    };
 }
+use msg_type;