Enum LicensePlan 

pub enum LicensePlan {
    None,
    Free,
    Supporter,
    Pro,
    Premium,
    Lifetime,
    Enterprise,
}

License plan tiers.

Each plan has different feature access. Only Pro, Premium, Lifetime, and Enterprise plans include verification capabilities.

Variants

None

No license or unknown plan.

Free

Free tier, no verification.

Supporter

Supporter tier, no verification.

Pro

Pro tier, includes verification.

Premium

Premium tier, includes verification.

Lifetime

Lifetime tier, includes verification.

Enterprise

Enterprise tier, includes verification.

Implementations

impl LicensePlan

pub fn can_verify(&self) -> bool

Check if this plan includes verification access.

Returns true for Pro, Premium, Lifetime, and Enterprise plans.

Examples

use logicaffeine_verify::LicensePlan;

assert!(!LicensePlan::Free.can_verify());
assert!(LicensePlan::Pro.can_verify());

pub fn from_str(s: &str) -> Self

Parse a plan from a string.

Returns LicensePlan::None for unrecognized strings.

Examples

use logicaffeine_verify::LicensePlan;

assert_eq!(LicensePlan::from_str("pro"), LicensePlan::Pro);
assert_eq!(LicensePlan::from_str("PRO"), LicensePlan::Pro);
assert_eq!(LicensePlan::from_str("unknown"), LicensePlan::None);

Trait Implementations

impl Clone for LicensePlan

fn clone(&self) -> LicensePlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LicensePlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LicensePlan

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LicensePlan

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

Formats the value using the given formatter.

impl PartialEq for LicensePlan

fn eq(&self, other: &LicensePlan) -> 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 Serialize for LicensePlan

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for LicensePlan

impl Eq for LicensePlan

impl StructuralPartialEq for LicensePlan