Enum DeviceType

pub enum DeviceType {
    Desktop,
    Mobile,
    Tablet,
    VR,
    TV,
    Unknown,
}

Enumeration for the different types of device.

Firefox Accounts and the broader Sync universe separates devices into broad categories for various purposes, such as distinguishing a desktop PC from a mobile phone.

A special variant in this enum, DeviceType::Unknown is used to capture the string values we don’t recognise. It also has a custom serde serializer and deserializer which implements the following semantics:

• deserializing a DeviceType which uses a string value we don’t recognise or null will return DeviceType::Unknown rather than returning an error.
• serializing DeviceType::Unknown will serialize null.

This has a few important implications:

• In general, Option<DeviceType> should be avoided, and a plain DeviceType used instead, because in that case, None would be semantically identical to DeviceType::Unknown and as mentioned above, null already deserializes as DeviceType::Unknown.
• Any unknown device types can not be round-tripped via this enum - eg, if you deserialize a struct holding a DeviceType string value we don’t recognize, then re-serialize it, the original string value is lost. We don’t consider this a problem because in practice, we only upload records with this device’s type, not the type of other devices, and it’s reasonable to assume that this module knows about all valid device types for the device type it is deployed on.

Variants

Desktop

Mobile

Tablet

VR

TV

Unknown

Trait Implementations

impl Clone for DeviceType

fn clone(&self) -> DeviceType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<UT> ConvertError<UT> for DeviceType

fn try_convert_unexpected_callback_error( e: UnexpectedUniFFICallbackError, ) -> Result<DeviceType, Error>

impl Debug for DeviceType

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

Formats the value using the given formatter.

impl Default for DeviceType

fn default() -> DeviceType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for DeviceType

fn deserialize<D>( deserializer: D, ) -> Result<DeviceType, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<UT> FfiConverter<UT> for DeviceType

const TYPE_ID_META: MetadataBuffer = _

Type ID metadata, serialized into a [MetadataBuffer].

type FfiType = RustBuffer

The low-level type used for passing values of this type over the FFI.

fn lower(v: DeviceType) -> RustBuffer

Lower a rust value of the target type, into an FFI value of type Self::FfiType.

fn try_lift(buf: RustBuffer) -> Result<DeviceType, Error>

Lift a rust value of the target type, from an FFI value of type Self::FfiType.

fn write(obj: DeviceType, buf: &mut Vec<u8>)

Write a rust value into a buffer, to send over the FFI in serialized form.

fn try_read(buf: &mut &[u8]) -> Result<DeviceType, Error>

Read a rust value from a buffer, received over the FFI in serialized form.

impl Hash for DeviceType

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

where __H: Hasher,

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<UT> Lift<UT> for DeviceType

type FfiType = <DeviceType as FfiConverter<UT>>::FfiType

fn try_lift(v: <DeviceType as Lift<UT>>::FfiType) -> Result<DeviceType, Error>

fn try_read(buf: &mut &[u8]) -> Result<DeviceType, Error>

fn try_lift_from_rust_buffer(v: RustBuffer) -> Result<Self, Error>

Convenience method

impl<UT> LiftRef<UT> for DeviceType

type LiftType = DeviceType

impl<UT> LiftReturn<UT> for DeviceType

type ReturnType = <DeviceType as Lift<UT>>::FfiType

FFI return type for trait interfaces

fn try_lift_successful_return( v: <DeviceType as LiftReturn<UT>>::ReturnType, ) -> Result<DeviceType, Error>

Lift a successfully returned value from a trait interface

fn lift_foreign_return( ffi_return: Self::ReturnType, call_status: RustCallStatus, ) -> Self

Lift a foreign returned value from a trait interface

fn lift_error(_buf: RustBuffer) -> Self

Lift a Rust value for a callback interface method error result

fn handle_callback_unexpected_error(e: UnexpectedUniFFICallbackError) -> Self

Lift a Rust value for an unexpected callback interface error

impl<UT> Lower<UT> for DeviceType

type FfiType = <DeviceType as FfiConverter<UT>>::FfiType

fn lower(obj: DeviceType) -> <DeviceType as Lower<UT>>::FfiType

fn write(obj: DeviceType, buf: &mut Vec<u8>)

fn lower_into_rust_buffer(obj: Self) -> RustBuffer

Convenience method

impl<UT> LowerError<UT> for DeviceType

fn lower_error(obj: DeviceType) -> RustBuffer

Lower this value for scaffolding function return

impl<UT> LowerReturn<UT> for DeviceType

type ReturnType = <DeviceType as Lower<UT>>::FfiType

The type that should be returned by scaffolding functions for this type.

fn lower_return( v: DeviceType, ) -> Result<<DeviceType as LowerReturn<UT>>::ReturnType, RustCallError>

Lower the return value from an scaffolding call

fn handle_failed_lift( error: LiftArgsError, ) -> Result<Self::ReturnType, RustCallError>

Lower the return value for failed argument lifts

impl PartialEq for DeviceType

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

fn serialize<S>( &self, s: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<UT> TypeId<UT> for DeviceType

const TYPE_ID_META: MetadataBuffer = _

impl Copy for DeviceType

impl Eq for DeviceType

impl StructuralPartialEq for DeviceType