1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104

use crate::properties::device_type::DeviceType;
use crate::properties::platform_name::PlatformName;
use crate::properties::browser_name::BrowserName;

pub mod device_type;
pub mod platform_name;
pub mod browser_name;

pub enum PropertyName {
    DeviceType,
    IsSmartPhone,
    IsMobile,
    IsTablet,
    HardwareName,
    HardwareModel,
    HardwareVendor,
    PlatformName,
    PlatformVersion,
    BrowserName,
    BrowserVersion,
}

impl From<&PropertyName> for usize {
    fn from(property_type: &PropertyName) -> Self {
        match property_type {
            PropertyName::DeviceType => 0,
            PropertyName::IsSmartPhone => 1,
            PropertyName::IsTablet => 2,
            PropertyName::HardwareName => 3,
            PropertyName::HardwareModel => 4,
            PropertyName::HardwareVendor => 5,
            PropertyName::PlatformName => 6,
            PropertyName::PlatformVersion => 7,
            PropertyName::BrowserName => 8,
            PropertyName::BrowserVersion => 9,
            PropertyName::IsMobile => 10
        }
    }
}

impl PropertyName {
    pub fn as_str(&self) -> &'static str {
        match self {
            PropertyName::DeviceType => "DeviceType",
            PropertyName::IsSmartPhone => "IsSmartPhone",
            PropertyName::IsTablet => "IsTablet",
            PropertyName::IsMobile => "IsMobile",
            PropertyName::HardwareName => "HardwareName",
            PropertyName::HardwareModel => "HardwareModel",
            PropertyName::HardwareVendor => "HardwareVendor",
            PropertyName::PlatformName => "PlatformName",
            PropertyName::PlatformVersion => "PlatformVersion",
            PropertyName::BrowserName => "BrowserName",
            PropertyName::BrowserVersion => "BrowserVersion"
        }
    }
}

#[derive(PartialEq, Debug)]
pub enum PropertyBooleanValue {
    IsSmartPhone(bool),
    IsTablet(bool),
}

#[derive(PartialEq, Debug)]
pub enum PropertyStringValue {
    DeviceType(DeviceType),
    HardwareName(String),
    HardwareModel(String),
    HardwareVendor(String),
    PlatformName(PlatformName),
    PlatformVersion(String),
    BrowserName(BrowserName),
    BrowserVersion(String),
}

impl PropertyStringValue {
    pub fn new(property_name: &PropertyName, value: String) -> Option<PropertyStringValue> {
        match property_name {
            PropertyName::HardwareName => Some(PropertyStringValue::HardwareName(value)),
            PropertyName::HardwareVendor => Some(PropertyStringValue::HardwareVendor(value)),
            PropertyName::HardwareModel => Some(PropertyStringValue::HardwareModel(value)),
            PropertyName::DeviceType => match DeviceType::from(value) {
                Some(converted) => Some(PropertyStringValue::DeviceType(converted)),
                _ => None
            },
            PropertyName::PlatformName => Some(PropertyStringValue::PlatformName(PlatformName::from(value))),
            PropertyName::BrowserName => Some(PropertyStringValue::BrowserName(BrowserName::from(value))),
            PropertyName::PlatformVersion => Some(PropertyStringValue::PlatformVersion(value)),
            PropertyName::BrowserVersion => Some(PropertyStringValue::BrowserVersion(value)),
            _ => panic!("The property name provided does not support string lookup.")
        }
    }
}

impl PropertyBooleanValue {
    pub fn new(property_name: &PropertyName, value: bool) -> PropertyBooleanValue {
        match property_name {
            PropertyName::IsSmartPhone => PropertyBooleanValue::IsSmartPhone(value),
            PropertyName::IsTablet => PropertyBooleanValue::IsTablet(value),
            _ => panic!("The property name provided does not support boolean lookup.")
        }
    }
}