Enum MessageAge 

pub enum MessageAge {
    Days(i64),
    Weeks(i64),
    Months(i64),
    Years(i64),
}

Message age specification for retention policies.

Defines different time periods that can be used to specify how old messages should be before they are subject to retention actions (trash/delete).

Examples

use cull_gmail::MessageAge;

// Create different message age specifications
let days = MessageAge::Days(30);
let weeks = MessageAge::Weeks(4);
let months = MessageAge::Months(6);
let years = MessageAge::Years(2);

// Use with retention policy
println!("Messages older than {} will be processed", months);

Variants

Days(i64)

Number of days to retain the message

Example

use cull_gmail::MessageAge;
let age = MessageAge::Days(30);
assert_eq!(age.to_string(), "d:30");

Weeks(i64)

Number of weeks to retain the message

Example

use cull_gmail::MessageAge;
let age = MessageAge::Weeks(4);
assert_eq!(age.to_string(), "w:4");

Months(i64)

Number of months to retain the message

Example

use cull_gmail::MessageAge;
let age = MessageAge::Months(6);
assert_eq!(age.to_string(), "m:6");

Years(i64)

Number of years to retain the message

Example

use cull_gmail::MessageAge;
let age = MessageAge::Years(2);
assert_eq!(age.to_string(), "y:2");

Implementations

impl MessageAge

pub fn new(period: &str, count: i64) -> Result<Self>

Create a new MessageAge from a period string and count.

Arguments

• period - The time period (“days”, “weeks”, “months”, “years”)
• count - The number of time periods (must be positive)

Examples

use cull_gmail::MessageAge;

let age = MessageAge::new("days", 30).unwrap();
assert_eq!(age, MessageAge::Days(30));

let age = MessageAge::new("months", 6).unwrap();
assert_eq!(age, MessageAge::Months(6));

// Invalid period returns an error
assert!(MessageAge::new("invalid", 1).is_err());

// Negative count returns an error
assert!(MessageAge::new("days", -1).is_err());

Errors

Returns an error if:

• The period string is not recognized
• The count is negative or zero

pub fn parse(s: &str) -> Option<MessageAge>

Parse a MessageAge from a string representation (e.g., “d:30”, “m:6”).

Arguments

• s - String in format “period:count” where period is d/w/m/y

Examples

use cull_gmail::MessageAge;

let age = MessageAge::parse("d:30").unwrap();
assert_eq!(age, MessageAge::Days(30));

let age = MessageAge::parse("y:2").unwrap();
assert_eq!(age, MessageAge::Years(2));

// Invalid format returns None
assert!(MessageAge::parse("invalid").is_none());
assert!(MessageAge::parse("d").is_none());

pub fn label(&self) -> String

Generate a label string for this message age.

This creates a standardized label that can be used to categorize messages based on their retention period.

Examples

use cull_gmail::MessageAge;

let age = MessageAge::Days(30);
assert_eq!(age.label(), "retention/30-days");

let age = MessageAge::Years(1);
assert_eq!(age.label(), "retention/1-years");

pub fn value(&self) -> i64

Get the numeric value of this message age.

Examples

use cull_gmail::MessageAge;

let age = MessageAge::Days(30);
assert_eq!(age.value(), 30);

let age = MessageAge::Years(2);
assert_eq!(age.value(), 2);

pub fn period_type(&self) -> &'static str

Get the period type as a string.

Examples

use cull_gmail::MessageAge;

let age = MessageAge::Days(30);
assert_eq!(age.period_type(), "days");

let age = MessageAge::Years(2);
assert_eq!(age.period_type(), "years");

Trait Implementations

impl Clone for MessageAge

fn clone(&self) -> MessageAge

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MessageAge

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for MessageAge

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for MessageAge

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for MessageAge

fn eq(&self, other: &MessageAge) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryFrom<&str> for MessageAge

fn try_from(value: &str) -> Result<Self>

Try to create a MessageAge from a string using the parse format.

Examples

use cull_gmail::MessageAge;
use std::convert::TryFrom;

let age = MessageAge::try_from("d:30").unwrap();
assert_eq!(age, MessageAge::Days(30));

let age = MessageAge::try_from("invalid");
assert!(age.is_err());

type Error = Error

The type returned in the event of a conversion error.

impl Eq for MessageAge

impl StructuralPartialEq for MessageAge