add own quota types and implement from trait

so that the ones from imap_proto can be converted easily

Author: Simon-Laux

src/client.rs

@@ -10,7 +10,7 @@ use async_std::io::{self, Read, Write};
 use async_std::net::{TcpStream, ToSocketAddrs};
 use async_std::prelude::*;
 use extensions::quota::parse_get_quota_root;
-use imap_proto::{Quota, QuotaRoot, RequestId, Response};
+use imap_proto::{RequestId, Response};
 
 use super::authenticator::Authenticator;
 use super::error::{Error, ParseError, Result, ValidateError};
@@ -1247,7 +1247,7 @@ impl<T: Read + Write + Unpin + fmt::Debug + Send> Session<T> {
     }
 
     /// The [`GETQUOTA` command](https://tools.ietf.org/html/rfc2087#section-4.2)
-    pub async fn get_quota(&mut self, quota_root: &str) -> Result<Quota<'_>> {
+    pub async fn get_quota(&mut self, quota_root: &str) -> Result<Quota> {
         let id = self
             .run_command(format!("GETQUOTA {}", quote!(quota_root)))
             .await?;
@@ -1264,7 +1264,7 @@ impl<T: Read + Write + Unpin + fmt::Debug + Send> Session<T> {
     pub async fn get_quota_root(
         &mut self,
         mailbox_name: &str,
-    ) -> Result<(Vec<QuotaRoot<'_>>, Vec<Quota<'_>>)> {
+    ) -> Result<(Vec<QuotaRoot>, Vec<Quota>)> {
         let id = self
             .run_command(format!("GETQUOTAROOT {}", quote!(mailbox_name)))
             .await?;

src/extensions/quota.rs

@@ -4,7 +4,7 @@ use async_std::channel;
 use async_std::io;
 use async_std::prelude::*;
 use async_std::stream::Stream;
-use imap_proto::{self, Quota, QuotaRoot, RequestId, Response};
+use imap_proto::{self, RequestId, Response};
 
 use crate::types::*;
 use crate::{
@@ -13,14 +13,14 @@ use crate::{
 };
 use crate::{
     error::{Error, ParseError},
-    types::ResponseData,
+    types::{Quota, QuotaRoot, ResponseData},
 };
 
 pub(crate) async fn parse_get_quota<T: Stream<Item = io::Result<ResponseData>> + Unpin>(
     stream: &mut T,
     unsolicited: channel::Sender<UnsolicitedResponse>,
     command_tag: RequestId,
-) -> Result<Quota<'_>> {
+) -> Result<Quota> {
     let mut quota = None;
     while let Some(resp) = stream
         .take_while(|res| filter_sync(res, &command_tag))
@@ -29,7 +29,7 @@ pub(crate) async fn parse_get_quota<T: Stream<Item = io::Result<ResponseData>> +
     {
         let resp = resp?;
         match resp.parsed() {
-            Response::Quota(q) => quota = Some(q.clone().into_owned()),
+            Response::Quota(q) => quota = Some(q.clone().into()),
             _ => {
                 handle_unilateral(resp, unsolicited.clone()).await;
             }
@@ -48,9 +48,9 @@ pub(crate) async fn parse_get_quota_root<T: Stream<Item = io::Result<ResponseDat
     stream: &mut T,
     unsolicited: channel::Sender<UnsolicitedResponse>,
     command_tag: RequestId,
-) -> Result<(Vec<QuotaRoot<'_>>, Vec<Quota<'_>>)> {
-    let mut roots: Vec<QuotaRoot<'_>> = Vec::new();
-    let mut quotas: Vec<Quota<'_>> = Vec::new();
+) -> Result<(Vec<QuotaRoot>, Vec<Quota>)> {
+    let mut roots: Vec<QuotaRoot> = Vec::new();
+    let mut quotas: Vec<Quota> = Vec::new();
 
     while let Some(resp) = stream
         .take_while(|res| filter_sync(res, &command_tag))
@@ -60,10 +60,10 @@ pub(crate) async fn parse_get_quota_root<T: Stream<Item = io::Result<ResponseDat
         let resp = resp?;
         match resp.parsed() {
             Response::QuotaRoot(qr) => {
-                roots.push(qr.clone().into_owned());
+                roots.push(qr.clone().into());
             }
             Response::Quota(q) => {
-                quotas.push(q.clone().into_owned());
+                quotas.push(q.clone().into());
             }
             _ => {
                 handle_unilateral(resp, unsolicited.clone()).await;

src/types/mod.rs

@@ -213,6 +213,9 @@ pub(crate) use self::response_data::ResponseData;
 mod request;
 pub(crate) use self::request::Request;
 
+mod quota;
+pub(crate) use self::quota::*;
+
 /// Responses that the server sends that are not related to the current command.
 /// [RFC 3501](https://tools.ietf.org/html/rfc3501#section-7) states that clients need to be able
 /// to accept any response at any time. These are the ones we've encountered in the wild.

src/types/quota.rs

@@ -0,0 +1,83 @@
+use imap_proto::types::Quota as QuotaRef;
+use imap_proto::types::QuotaResource as QuotaResourceRef;
+use imap_proto::types::QuotaResourceName as QuotaResourceNameRef;
+use imap_proto::types::QuotaRoot as QuotaRootRef;
+
+/// https://tools.ietf.org/html/rfc2087#section-3
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub enum QuotaResourceName {
+    /// Sum of messages' RFC822.SIZE, in units of 1024 octets
+    Storage,
+    /// Number of messages
+    Message,
+    Atom(String),
+}
+
+impl<'a> From<QuotaResourceNameRef<'a>> for QuotaResourceName {
+    fn from(name: QuotaResourceNameRef<'_>) -> Self {
+        match name {
+            QuotaResourceNameRef::Message => QuotaResourceName::Message,
+            QuotaResourceNameRef::Storage => QuotaResourceName::Storage,
+            QuotaResourceNameRef::Atom(v) => QuotaResourceName::Atom(v.to_string()),
+        }
+    }
+}
+
+/// 5.1. QUOTA Response (https://tools.ietf.org/html/rfc2087#section-5.1)
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct QuotaResource {
+    pub name: QuotaResourceName,
+    /// current usage of the resource
+    pub usage: u64,
+    /// resource limit
+    pub limit: u64,
+}
+
+impl<'a> From<QuotaResourceRef<'a>> for QuotaResource {
+    fn from(resource: QuotaResourceRef<'_>) -> Self {
+        Self {
+            name: resource.name.into(),
+            usage: resource.usage,
+            limit: resource.limit,
+        }
+    }
+}
+
+/// 5.1. QUOTA Response (https://tools.ietf.org/html/rfc2087#section-5.1)
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct Quota {
+    /// quota root name
+    pub root_name: String,
+    pub resources: Vec<QuotaResource>,
+}
+
+impl<'a> From<QuotaRef<'a>> for Quota {
+    fn from(quota: QuotaRef<'_>) -> Self {
+        Self {
+            root_name: quota.root_name.to_string(),
+            resources: quota.resources.iter().map(|r| r.clone().into()).collect(),
+        }
+    }
+}
+
+/// 5.2. QUOTAROOT Response (https://tools.ietf.org/html/rfc2087#section-5.2)
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct QuotaRoot {
+    /// mailbox name
+    pub mailbox_name: String,
+    /// zero or more quota root names
+    pub quota_root_names: Vec<String>,
+}
+
+impl<'a> From<QuotaRootRef<'a>> for QuotaRoot {
+    fn from(root: QuotaRootRef<'_>) -> Self {
+        Self {
+            mailbox_name: root.mailbox_name.to_string(),
+            quota_root_names: root
+                .quota_root_names
+                .iter()
+                .map(|n| n.to_string())
+                .collect(),
+        }
+    }
+}