Struct Fixed

pub struct Fixed(/* private fields */);

A signed 24.8 fixed-point number used in the wayland protocol.

This is a signed decimal type which offers a sign bit, 23 bits of integer precision and 8 bits of decimal precision.

Arithmetic operations

This type implements all of the usual arithmetic operations for numbers. On overflow, they behave like the standard library operations except that multiplication and division always use wrapping semantics.

Implementations

impl Fixed

pub const MAX: Self

The largest Fixed.

pub const MIN: Self

The smallest Fixed.

pub const ZERO: Self

The 0 Fixed.

pub const ONE: Self

The 1 Fixed.

pub const TWO: Self

The 2 Fixed.

pub const EPSILON: Self

The smallest positive Fixed.

pub const NEGATIVE_EPSILON: Self

The largest negative Fixed.

pub const fn from_wire(val: i32) -> Self

Creates a Fixed from the raw bits that appear in the wire protocol.

Examples found in repository

examples/poll-integration/../common/protocols/tablet_v2/zwp_tablet_pad_ring_v2.rs (line 361)

    unsafe fn handle_event(
        &self,
        queue: &Queue,
        slf: &UntypedBorrowedProxy,
        opcode: u32,
        args: *mut wl_argument,
    ) {
        // SAFETY: This function required that slf has the interface INTERFACE
        let slf = unsafe { proxy::low_level::from_untyped_borrowed::<ZwpTabletPadRingV2Ref>(slf) };
        match opcode {
            0 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { ZwpTabletPadRingV2Source(args[0].u) };
                self.0.source(slf, arg0);
            }
            1 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a fixed
                let arg0 = unsafe { Fixed::from_wire(args[0].f) };
                self.0.angle(slf, arg0);
            }
            2 => {
                self.0.stop(slf);
            }
            3 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                self.0.frame(slf, arg0);
            }
            _ => {
                invalid_opcode("zwp_tablet_pad_ring_v2", opcode);
            }
        }
    }

examples/poll-integration/../common/protocols/wayland/wl_touch.rs (line 451)

    unsafe fn handle_event(
        &self,
        queue: &Queue,
        slf: &UntypedBorrowedProxy,
        opcode: u32,
        args: *mut wl_argument,
    ) {
        // SAFETY: This function required that slf has the interface INTERFACE
        let slf = unsafe { proxy::low_level::from_untyped_borrowed::<WlTouchRef>(slf) };
        match opcode {
            0 => {
                // SAFETY: INTERFACE requires that there are 6 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 6]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { args[1].u };
                // SAFETY: - INTERFACE requires that args[2] contains an object
                let arg2 = unsafe {
                    if let Some(p) = NonNull::new(args[2].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                // SAFETY: - INTERFACE requires that the object has the interface WlSurface::WL_INTERFACE
                let arg2 = arg2.as_ref().map(|arg2| unsafe {
                    proxy::low_level::from_untyped_borrowed::<WlSurfaceRef>(arg2)
                });
                // SAFETY: - INTERFACE requires that args[3] contains an int
                let arg3 = unsafe { args[3].i };
                // SAFETY: - INTERFACE requires that args[4] contains a fixed
                let arg4 = unsafe { Fixed::from_wire(args[4].f) };
                // SAFETY: - INTERFACE requires that args[5] contains a fixed
                let arg5 = unsafe { Fixed::from_wire(args[5].f) };
                self.0.down(slf, arg0, arg1, arg2, arg3, arg4, arg5);
            }
            1 => {
                // SAFETY: INTERFACE requires that there are 3 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 3]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { args[1].u };
                // SAFETY: - INTERFACE requires that args[2] contains an int
                let arg2 = unsafe { args[2].i };
                self.0.up(slf, arg0, arg1, arg2);
            }
            2 => {
                // SAFETY: INTERFACE requires that there are 4 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 4]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains an int
                let arg1 = unsafe { args[1].i };
                // SAFETY: - INTERFACE requires that args[2] contains a fixed
                let arg2 = unsafe { Fixed::from_wire(args[2].f) };
                // SAFETY: - INTERFACE requires that args[3] contains a fixed
                let arg3 = unsafe { Fixed::from_wire(args[3].f) };
                self.0.motion(slf, arg0, arg1, arg2, arg3);
            }
            3 => {
                self.0.frame(slf);
            }
            4 => {
                self.0.cancel(slf);
            }
            5 => {
                // SAFETY: INTERFACE requires that there are 3 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 3]>() };
                // SAFETY: - INTERFACE requires that args[0] contains an int
                let arg0 = unsafe { args[0].i };
                // SAFETY: - INTERFACE requires that args[1] contains a fixed
                let arg1 = unsafe { Fixed::from_wire(args[1].f) };
                // SAFETY: - INTERFACE requires that args[2] contains a fixed
                let arg2 = unsafe { Fixed::from_wire(args[2].f) };
                self.0.shape(slf, arg0, arg1, arg2);
            }
            6 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains an int
                let arg0 = unsafe { args[0].i };
                // SAFETY: - INTERFACE requires that args[1] contains a fixed
                let arg1 = unsafe { Fixed::from_wire(args[1].f) };
                self.0.orientation(slf, arg0, arg1);
            }
            _ => {
                invalid_opcode("wl_touch", opcode);
            }
        }
    }

examples/poll-integration/../common/protocols/wayland/wl_data_device.rs (line 535)

    unsafe fn handle_event(
        &self,
        queue: &Queue,
        slf: &UntypedBorrowedProxy,
        opcode: u32,
        args: *mut wl_argument,
    ) {
        // SAFETY: This function required that slf has the interface INTERFACE
        let slf = unsafe { proxy::low_level::from_untyped_borrowed::<WlDataDeviceRef>(slf) };
        match opcode {
            0 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains an object
                //         - ownership is transferred to this function
                //         - INTERFACE requires that the object has the interface WlDataOffer::WL_INTERFACE
                let arg0 = unsafe {
                    UntypedOwnedProxy::from_plain_wl_proxy(
                        queue,
                        NonNull::new_unchecked(args[0].o.cast()),
                        WlDataOffer::WL_INTERFACE,
                    )
                };
                // SAFETY: - INTERFACE requires that the object has the interface WlDataOffer::WL_INTERFACE
                let arg0 = unsafe { proxy::low_level::from_untyped_owned::<WlDataOffer>(arg0) };
                self.0.data_offer(slf, arg0);
            }
            1 => {
                // SAFETY: INTERFACE requires that there are 5 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 5]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains an object
                let arg1 = unsafe {
                    if let Some(p) = NonNull::new(args[1].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                // SAFETY: - INTERFACE requires that the object has the interface WlSurface::WL_INTERFACE
                let arg1 = arg1.as_ref().map(|arg1| unsafe {
                    proxy::low_level::from_untyped_borrowed::<WlSurfaceRef>(arg1)
                });
                // SAFETY: - INTERFACE requires that args[2] contains a fixed
                let arg2 = unsafe { Fixed::from_wire(args[2].f) };
                // SAFETY: - INTERFACE requires that args[3] contains a fixed
                let arg3 = unsafe { Fixed::from_wire(args[3].f) };
                // SAFETY: - INTERFACE requires that args[4] contains an object
                let arg4 = unsafe {
                    if let Some(p) = NonNull::new(args[4].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                // SAFETY: - INTERFACE requires that the object has the interface WlDataOffer::WL_INTERFACE
                let arg4 = arg4.as_ref().map(|arg4| unsafe {
                    proxy::low_level::from_untyped_borrowed::<WlDataOfferRef>(arg4)
                });
                self.0.enter(slf, arg0, arg1, arg2, arg3, arg4);
            }
            2 => {
                self.0.leave(slf);
            }
            3 => {
                // SAFETY: INTERFACE requires that there are 3 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 3]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a fixed
                let arg1 = unsafe { Fixed::from_wire(args[1].f) };
                // SAFETY: - INTERFACE requires that args[2] contains a fixed
                let arg2 = unsafe { Fixed::from_wire(args[2].f) };
                self.0.motion(slf, arg0, arg1, arg2);
            }
            4 => {
                self.0.drop(slf);
            }
            5 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains an object
                let arg0 = unsafe {
                    if let Some(p) = NonNull::new(args[0].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                // SAFETY: - INTERFACE requires that the object has the interface WlDataOffer::WL_INTERFACE
                let arg0 = arg0.as_ref().map(|arg0| unsafe {
                    proxy::low_level::from_untyped_borrowed::<WlDataOfferRef>(arg0)
                });
                self.0.selection(slf, arg0);
            }
            _ => {
                invalid_opcode("wl_data_device", opcode);
            }
        }
    }

examples/poll-integration/../common/protocols/wayland/wl_pointer.rs (line 787)

    unsafe fn handle_event(
        &self,
        queue: &Queue,
        slf: &UntypedBorrowedProxy,
        opcode: u32,
        args: *mut wl_argument,
    ) {
        // SAFETY: This function required that slf has the interface INTERFACE
        let slf = unsafe { proxy::low_level::from_untyped_borrowed::<WlPointerRef>(slf) };
        match opcode {
            0 => {
                // SAFETY: INTERFACE requires that there are 4 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 4]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains an object
                let arg1 = unsafe {
                    if let Some(p) = NonNull::new(args[1].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                // SAFETY: - INTERFACE requires that the object has the interface WlSurface::WL_INTERFACE
                let arg1 = arg1.as_ref().map(|arg1| unsafe {
                    proxy::low_level::from_untyped_borrowed::<WlSurfaceRef>(arg1)
                });
                // SAFETY: - INTERFACE requires that args[2] contains a fixed
                let arg2 = unsafe { Fixed::from_wire(args[2].f) };
                // SAFETY: - INTERFACE requires that args[3] contains a fixed
                let arg3 = unsafe { Fixed::from_wire(args[3].f) };
                self.0.enter(slf, arg0, arg1, arg2, arg3);
            }
            1 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains an object
                let arg1 = unsafe {
                    if let Some(p) = NonNull::new(args[1].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                // SAFETY: - INTERFACE requires that the object has the interface WlSurface::WL_INTERFACE
                let arg1 = arg1.as_ref().map(|arg1| unsafe {
                    proxy::low_level::from_untyped_borrowed::<WlSurfaceRef>(arg1)
                });
                self.0.leave(slf, arg0, arg1);
            }
            2 => {
                // SAFETY: INTERFACE requires that there are 3 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 3]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a fixed
                let arg1 = unsafe { Fixed::from_wire(args[1].f) };
                // SAFETY: - INTERFACE requires that args[2] contains a fixed
                let arg2 = unsafe { Fixed::from_wire(args[2].f) };
                self.0.motion(slf, arg0, arg1, arg2);
            }
            3 => {
                // SAFETY: INTERFACE requires that there are 4 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 4]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { args[1].u };
                // SAFETY: - INTERFACE requires that args[2] contains a uint
                let arg2 = unsafe { args[2].u };
                // SAFETY: - INTERFACE requires that args[3] contains a uint
                let arg3 = unsafe { WlPointerButtonState(args[3].u) };
                self.0.button(slf, arg0, arg1, arg2, arg3);
            }
            4 => {
                // SAFETY: INTERFACE requires that there are 3 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 3]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { WlPointerAxis(args[1].u) };
                // SAFETY: - INTERFACE requires that args[2] contains a fixed
                let arg2 = unsafe { Fixed::from_wire(args[2].f) };
                self.0.axis(slf, arg0, arg1, arg2);
            }
            5 => {
                self.0.frame(slf);
            }
            6 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { WlPointerAxisSource(args[0].u) };
                self.0.axis_source(slf, arg0);
            }
            7 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { WlPointerAxis(args[1].u) };
                self.0.axis_stop(slf, arg0, arg1);
            }
            8 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { WlPointerAxis(args[0].u) };
                // SAFETY: - INTERFACE requires that args[1] contains an int
                let arg1 = unsafe { args[1].i };
                self.0.axis_discrete(slf, arg0, arg1);
            }
            9 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { WlPointerAxis(args[0].u) };
                // SAFETY: - INTERFACE requires that args[1] contains an int
                let arg1 = unsafe { args[1].i };
                self.0.axis_value120(slf, arg0, arg1);
            }
            10 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { WlPointerAxis(args[0].u) };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { WlPointerAxisRelativeDirection(args[1].u) };
                self.0.axis_relative_direction(slf, arg0, arg1);
            }
            _ => {
                invalid_opcode("wl_pointer", opcode);
            }
        }
    }

examples/poll-integration/../common/protocols/tablet_v2/zwp_tablet_tool_v2.rs (line 957)

    unsafe fn handle_event(
        &self,
        queue: &Queue,
        slf: &UntypedBorrowedProxy,
        opcode: u32,
        args: *mut wl_argument,
    ) {
        // SAFETY: This function required that slf has the interface INTERFACE
        let slf = unsafe { proxy::low_level::from_untyped_borrowed::<ZwpTabletToolV2Ref>(slf) };
        match opcode {
            0 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { ZwpTabletToolV2Type(args[0].u) };
                self.0.r#type(slf, arg0);
            }
            1 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { args[1].u };
                self.0.hardware_serial(slf, arg0, arg1);
            }
            2 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { args[1].u };
                self.0.hardware_id_wacom(slf, arg0, arg1);
            }
            3 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { ZwpTabletToolV2Capability(args[0].u) };
                self.0.capability(slf, arg0);
            }
            4 => {
                self.0.done(slf);
            }
            5 => {
                self.0.removed(slf);
            }
            6 => {
                // SAFETY: INTERFACE requires that there are 3 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 3]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains an object
                let arg1 = unsafe {
                    if let Some(p) = NonNull::new(args[1].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                // SAFETY: - INTERFACE requires that the object has the interface ZwpTabletV2::WL_INTERFACE
                let arg1 = arg1.as_ref().map(|arg1| unsafe {
                    proxy::low_level::from_untyped_borrowed::<ZwpTabletV2Ref>(arg1)
                });
                // SAFETY: - INTERFACE requires that args[2] contains an object
                let arg2 = unsafe {
                    if let Some(p) = NonNull::new(args[2].o.cast()) {
                        Some(UntypedBorrowedProxy::new_immutable(queue.libwayland(), p))
                    } else {
                        None
                    }
                };
                // SAFETY: - INTERFACE requires that the object has the interface WlSurface::WL_INTERFACE
                let arg2 = arg2.as_ref().map(|arg2| unsafe {
                    proxy::low_level::from_untyped_borrowed::<WlSurfaceRef>(arg2)
                });
                self.0.proximity_in(slf, arg0, arg1, arg2);
            }
            7 => {
                self.0.proximity_out(slf);
            }
            8 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                self.0.down(slf, arg0);
            }
            9 => {
                self.0.up(slf);
            }
            10 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a fixed
                let arg0 = unsafe { Fixed::from_wire(args[0].f) };
                // SAFETY: - INTERFACE requires that args[1] contains a fixed
                let arg1 = unsafe { Fixed::from_wire(args[1].f) };
                self.0.motion(slf, arg0, arg1);
            }
            11 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                self.0.pressure(slf, arg0);
            }
            12 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                self.0.distance(slf, arg0);
            }
            13 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a fixed
                let arg0 = unsafe { Fixed::from_wire(args[0].f) };
                // SAFETY: - INTERFACE requires that args[1] contains a fixed
                let arg1 = unsafe { Fixed::from_wire(args[1].f) };
                self.0.tilt(slf, arg0, arg1);
            }
            14 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a fixed
                let arg0 = unsafe { Fixed::from_wire(args[0].f) };
                self.0.rotation(slf, arg0);
            }
            15 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains an int
                let arg0 = unsafe { args[0].i };
                self.0.slider(slf, arg0);
            }
            16 => {
                // SAFETY: INTERFACE requires that there are 2 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 2]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a fixed
                let arg0 = unsafe { Fixed::from_wire(args[0].f) };
                // SAFETY: - INTERFACE requires that args[1] contains an int
                let arg1 = unsafe { args[1].i };
                self.0.wheel(slf, arg0, arg1);
            }
            17 => {
                // SAFETY: INTERFACE requires that there are 3 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 3]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                // SAFETY: - INTERFACE requires that args[1] contains a uint
                let arg1 = unsafe { args[1].u };
                // SAFETY: - INTERFACE requires that args[2] contains a uint
                let arg2 = unsafe { ZwpTabletToolV2ButtonState(args[2].u) };
                self.0.button(slf, arg0, arg1, arg2);
            }
            18 => {
                // SAFETY: INTERFACE requires that there are 1 arguments
                let args = unsafe { &*args.cast::<[wl_argument; 1]>() };
                // SAFETY: - INTERFACE requires that args[0] contains a uint
                let arg0 = unsafe { args[0].u };
                self.0.frame(slf, arg0);
            }
            _ => {
                invalid_opcode("zwp_tablet_tool_v2", opcode);
            }
        }
    }

pub const fn to_wire(self) -> i32

Converts this Fixed to the bits that should be set in the wire protocol.

Examples found in repository

examples/poll-integration/../common/protocols/viewporter/wp_viewport.rs (line 231)

    pub fn set_source(&self, x: Fixed, y: Fixed, width: Fixed, height: Fixed) {
        let (arg0, arg1, arg2, arg3) = (x, y, width, height);
        let mut args = [
            wl_argument { f: arg0.to_wire() },
            wl_argument { f: arg1.to_wire() },
            wl_argument { f: arg2.to_wire() },
            wl_argument { f: arg3.to_wire() },
        ];
        // SAFETY: - self.proxy has the interface INTERFACE
        //         - 1 < INTERFACE.method_count = 3
        //         - the request signature is `ffff`
        unsafe {
            self.proxy.send_request(1, &mut args);
        }
    }

pub const fn to_f64(self) -> f64

Converts this Fixed to an f64.

This conversion is lossless.

pub const fn to_f32_lossy(self) -> f32

Converts this Fixed to an f32.

This conversion is lossy if there are more than 24 significant bits in this Fixed.

pub const fn from_f64_lossy(val: f64) -> Self

Creates a Fixed from an f64.

If the value cannot be represented exactly, the behavior is as when an f64 is cast to an integer. That is

• Values are rounded towards 0.
• NaN returns Fixed::ZERO.
• Values larger than the maximum return Fixed::MAX.
• Values smaller than the minimum return Fixed::MIN.

pub const fn from_f32_lossy(val: f32) -> Self

Creates a Fixed from an f32.

The conversion behavior is the same as for Fixed::from_f64_lossy.

pub const fn from_i32_saturating(val: i32) -> Self

Creates a Fixed from an i32.

Values outside of the representable range are clamped to Fixed::MIN and Fixed::MAX.

pub const fn from_i64_saturating(val: i64) -> Self

Creates a Fixed from an i64.

Values outside of the representable range are clamped to Fixed::MIN and Fixed::MAX.

pub const fn to_i32_round_towards_nearest(self) -> i32

Converts this Fixed to an i32.

The conversion rounds towards the nearest integer and half-way away from 0.

pub const fn to_i32_round_towards_zero(self) -> i32

Converts this Fixed to an i32.

The conversion rounds towards zero.

pub const fn to_i32_floor(self) -> i32

Converts this Fixed to an i32.

The conversion rounds towards minus infinity.

pub const fn to_i32_ceil(self) -> i32

Converts this Fixed to an i32.

The conversion rounds towards infinity.

Trait Implementations

impl Add<&Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the + operator.

fn add(self, rhs: &Fixed) -> Self::Output

Performs the + operation.

impl Add<&Fixed> for Fixed

type Output = Fixed

The resulting type after applying the + operator.

fn add(self, rhs: &Fixed) -> Self::Output

Performs the + operation.

impl Add<Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the + operator.

fn add(self, rhs: Fixed) -> Self::Output

Performs the + operation.

impl Add for Fixed

type Output = Fixed

The resulting type after applying the + operator.

fn add(self, rhs: Fixed) -> Self::Output

Performs the + operation.

impl AddAssign for Fixed

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl BitAnd<&Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the & operator.

fn bitand(self, rhs: &Fixed) -> Self::Output

Performs the & operation.

impl BitAnd<&Fixed> for Fixed

type Output = Fixed

The resulting type after applying the & operator.

fn bitand(self, rhs: &Fixed) -> Self::Output

Performs the & operation.

impl BitAnd<Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the & operator.

fn bitand(self, rhs: Fixed) -> Self::Output

Performs the & operation.

impl BitAnd for Fixed

type Output = Fixed

The resulting type after applying the & operator.

fn bitand(self, rhs: Fixed) -> Self::Output

Performs the & operation.

impl BitAndAssign for Fixed

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<&Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the | operator.

fn bitor(self, rhs: &Fixed) -> Self::Output

Performs the | operation.

impl BitOr<&Fixed> for Fixed

type Output = Fixed

The resulting type after applying the | operator.

fn bitor(self, rhs: &Fixed) -> Self::Output

Performs the | operation.

impl BitOr<Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the | operator.

fn bitor(self, rhs: Fixed) -> Self::Output

Performs the | operation.

impl BitOr for Fixed

type Output = Fixed

The resulting type after applying the | operator.

fn bitor(self, rhs: Fixed) -> Self::Output

Performs the | operation.

impl BitOrAssign for Fixed

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor<&Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Fixed) -> Self::Output

Performs the ^ operation.

impl BitXor<&Fixed> for Fixed

type Output = Fixed

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Fixed) -> Self::Output

Performs the ^ operation.

impl BitXor<Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Fixed) -> Self::Output

Performs the ^ operation.

impl BitXor for Fixed

type Output = Fixed

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Fixed) -> Self::Output

Performs the ^ operation.

impl BitXorAssign for Fixed

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for Fixed

fn clone(&self) -> Fixed

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Fixed

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

Formats the value using the given formatter.

impl Display for Fixed

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

Formats the value using the given formatter.

impl Div<&Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the / operator.

fn div(self, rhs: &Fixed) -> Self::Output

Performs the / operation.

impl Div<&Fixed> for Fixed

type Output = Fixed

The resulting type after applying the / operator.

fn div(self, rhs: &Fixed) -> Self::Output

Performs the / operation.

impl Div<Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the / operator.

fn div(self, rhs: Fixed) -> Self::Output

Performs the / operation.

impl Div for Fixed

type Output = Fixed

The resulting type after applying the / operator.

fn div(self, rhs: Fixed) -> Self::Output

Performs the / operation.

impl DivAssign for Fixed

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl From<Fixed> for f64

fn from(value: Fixed) -> Self

Converts to this type from the input type.

impl From<i16> for Fixed

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i8> for Fixed

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<u16> for Fixed

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u8> for Fixed

fn from(value: u8) -> Self

Converts to this type from the input type.

impl Hash for Fixed

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 Mul<&Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the * operator.

fn mul(self, rhs: &Fixed) -> Self::Output

Performs the * operation.

impl Mul<&Fixed> for Fixed

type Output = Fixed

The resulting type after applying the * operator.

fn mul(self, rhs: &Fixed) -> Self::Output

Performs the * operation.

impl Mul<Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed) -> Self::Output

Performs the * operation.

impl Mul for Fixed

type Output = Fixed

The resulting type after applying the * operator.

fn mul(self, rhs: Fixed) -> Self::Output

Performs the * operation.

impl MulAssign for Fixed

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for &Fixed

type Output = Fixed

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for Fixed

type Output = Fixed

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for &Fixed

type Output = Fixed

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for Fixed

type Output = Fixed

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Ord for Fixed

fn cmp(&self, other: &Fixed) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Fixed

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

fn partial_cmp(&self, other: &Fixed) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Rem<&Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the % operator.

fn rem(self, rhs: &Fixed) -> Self::Output

Performs the % operation.

impl Rem<&Fixed> for Fixed

type Output = Fixed

The resulting type after applying the % operator.

fn rem(self, rhs: &Fixed) -> Self::Output

Performs the % operation.

impl Rem<Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the % operator.

fn rem(self, rhs: Fixed) -> Self::Output

Performs the % operation.

impl Rem for Fixed

type Output = Fixed

The resulting type after applying the % operator.

fn rem(self, rhs: Fixed) -> Self::Output

Performs the % operation.

impl RemAssign for Fixed

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl Shl<&i128> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i128) -> Self::Output

Performs the << operation.

impl Shl<&i128> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i128) -> Self::Output

Performs the << operation.

impl Shl<&i16> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> Self::Output

Performs the << operation.

impl Shl<&i16> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i16) -> Self::Output

Performs the << operation.

impl Shl<&i32> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> Self::Output

Performs the << operation.

impl Shl<&i32> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i32) -> Self::Output

Performs the << operation.

impl Shl<&i64> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> Self::Output

Performs the << operation.

impl Shl<&i64> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i64) -> Self::Output

Performs the << operation.

impl Shl<&i8> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> Self::Output

Performs the << operation.

impl Shl<&i8> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &i8) -> Self::Output

Performs the << operation.

impl Shl<&isize> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Self::Output

Performs the << operation.

impl Shl<&isize> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &isize) -> Self::Output

Performs the << operation.

impl Shl<&u128> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u128) -> Self::Output

Performs the << operation.

impl Shl<&u128> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u128) -> Self::Output

Performs the << operation.

impl Shl<&u16> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> Self::Output

Performs the << operation.

impl Shl<&u16> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u16) -> Self::Output

Performs the << operation.

impl Shl<&u32> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Self::Output

Performs the << operation.

impl Shl<&u32> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u32) -> Self::Output

Performs the << operation.

impl Shl<&u64> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> Self::Output

Performs the << operation.

impl Shl<&u64> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u64) -> Self::Output

Performs the << operation.

impl Shl<&u8> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> Self::Output

Performs the << operation.

impl Shl<&u8> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &u8) -> Self::Output

Performs the << operation.

impl Shl<&usize> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> Self::Output

Performs the << operation.

impl Shl<&usize> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: &usize) -> Self::Output

Performs the << operation.

impl Shl<i128> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i128) -> Self::Output

Performs the << operation.

impl Shl<i128> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i128) -> Self::Output

Performs the << operation.

impl Shl<i16> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> Self::Output

Performs the << operation.

impl Shl<i16> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> Self::Output

Performs the << operation.

impl Shl<i32> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Self::Output

Performs the << operation.

impl Shl<i32> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> Self::Output

Performs the << operation.

impl Shl<i64> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> Self::Output

Performs the << operation.

impl Shl<i64> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i64) -> Self::Output

Performs the << operation.

impl Shl<i8> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> Self::Output

Performs the << operation.

impl Shl<i8> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> Self::Output

Performs the << operation.

impl Shl<isize> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Self::Output

Performs the << operation.

impl Shl<isize> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: isize) -> Self::Output

Performs the << operation.

impl Shl<u128> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u128) -> Self::Output

Performs the << operation.

impl Shl<u128> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u128) -> Self::Output

Performs the << operation.

impl Shl<u16> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl Shl<u16> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> Self::Output

Performs the << operation.

impl Shl<u32> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl Shl<u32> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> Self::Output

Performs the << operation.

impl Shl<u64> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> Self::Output

Performs the << operation.

impl Shl<u64> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u64) -> Self::Output

Performs the << operation.

impl Shl<u8> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> Self::Output

Performs the << operation.

impl Shl<u8> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> Self::Output

Performs the << operation.

impl Shl<usize> for &Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation.

impl Shl<usize> for Fixed

type Output = Fixed

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation.

impl ShlAssign<&i128> for Fixed

fn shl_assign(&mut self, rhs: &i128)

Performs the <<= operation.

impl ShlAssign<&i16> for Fixed

fn shl_assign(&mut self, rhs: &i16)

Performs the <<= operation.

impl ShlAssign<&i32> for Fixed

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation.

impl ShlAssign<&i64> for Fixed

fn shl_assign(&mut self, rhs: &i64)

Performs the <<= operation.

impl ShlAssign<&i8> for Fixed

fn shl_assign(&mut self, rhs: &i8)

Performs the <<= operation.

impl ShlAssign<&isize> for Fixed

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation.

impl ShlAssign<&u128> for Fixed

fn shl_assign(&mut self, rhs: &u128)

Performs the <<= operation.

impl ShlAssign<&u16> for Fixed

fn shl_assign(&mut self, rhs: &u16)

Performs the <<= operation.

impl ShlAssign<&u32> for Fixed

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation.

impl ShlAssign<&u64> for Fixed

fn shl_assign(&mut self, rhs: &u64)

Performs the <<= operation.

impl ShlAssign<&u8> for Fixed

fn shl_assign(&mut self, rhs: &u8)

Performs the <<= operation.

impl ShlAssign<&usize> for Fixed

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation.

impl ShlAssign<i128> for Fixed

fn shl_assign(&mut self, rhs: i128)

Performs the <<= operation.

impl ShlAssign<i16> for Fixed

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation.

impl ShlAssign<i32> for Fixed

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl ShlAssign<i64> for Fixed

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation.

impl ShlAssign<i8> for Fixed

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation.

impl ShlAssign<isize> for Fixed

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation.

impl ShlAssign<u128> for Fixed

fn shl_assign(&mut self, rhs: u128)

Performs the <<= operation.

impl ShlAssign<u16> for Fixed

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation.

impl ShlAssign<u32> for Fixed

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl ShlAssign<u64> for Fixed

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation.

impl ShlAssign<u8> for Fixed

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation.

impl ShlAssign<usize> for Fixed

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<&i128> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i128) -> Self::Output

Performs the >> operation.

impl Shr<&i128> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i128) -> Self::Output

Performs the >> operation.

impl Shr<&i16> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> Self::Output

Performs the >> operation.

impl Shr<&i16> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i16) -> Self::Output

Performs the >> operation.

impl Shr<&i32> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> Self::Output

Performs the >> operation.

impl Shr<&i32> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i32) -> Self::Output

Performs the >> operation.

impl Shr<&i64> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> Self::Output

Performs the >> operation.

impl Shr<&i64> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i64) -> Self::Output

Performs the >> operation.

impl Shr<&i8> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> Self::Output

Performs the >> operation.

impl Shr<&i8> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &i8) -> Self::Output

Performs the >> operation.

impl Shr<&isize> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Self::Output

Performs the >> operation.

impl Shr<&isize> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &isize) -> Self::Output

Performs the >> operation.

impl Shr<&u128> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u128) -> Self::Output

Performs the >> operation.

impl Shr<&u128> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u128) -> Self::Output

Performs the >> operation.

impl Shr<&u16> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> Self::Output

Performs the >> operation.

impl Shr<&u16> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u16) -> Self::Output

Performs the >> operation.

impl Shr<&u32> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Self::Output

Performs the >> operation.

impl Shr<&u32> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u32) -> Self::Output

Performs the >> operation.

impl Shr<&u64> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> Self::Output

Performs the >> operation.

impl Shr<&u64> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u64) -> Self::Output

Performs the >> operation.

impl Shr<&u8> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> Self::Output

Performs the >> operation.

impl Shr<&u8> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &u8) -> Self::Output

Performs the >> operation.

impl Shr<&usize> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> Self::Output

Performs the >> operation.

impl Shr<&usize> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: &usize) -> Self::Output

Performs the >> operation.

impl Shr<i128> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i128) -> Self::Output

Performs the >> operation.

impl Shr<i128> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i128) -> Self::Output

Performs the >> operation.

impl Shr<i16> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> Self::Output

Performs the >> operation.

impl Shr<i16> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> Self::Output

Performs the >> operation.

impl Shr<i32> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Self::Output

Performs the >> operation.

impl Shr<i32> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> Self::Output

Performs the >> operation.

impl Shr<i64> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> Self::Output

Performs the >> operation.

impl Shr<i64> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i64) -> Self::Output

Performs the >> operation.

impl Shr<i8> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> Self::Output

Performs the >> operation.

impl Shr<i8> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> Self::Output

Performs the >> operation.

impl Shr<isize> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Self::Output

Performs the >> operation.

impl Shr<isize> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: isize) -> Self::Output

Performs the >> operation.

impl Shr<u128> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u128) -> Self::Output

Performs the >> operation.

impl Shr<u128> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u128) -> Self::Output

Performs the >> operation.

impl Shr<u16> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl Shr<u16> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> Self::Output

Performs the >> operation.

impl Shr<u32> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl Shr<u32> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> Self::Output

Performs the >> operation.

impl Shr<u64> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> Self::Output

Performs the >> operation.

impl Shr<u64> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u64) -> Self::Output

Performs the >> operation.

impl Shr<u8> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> Self::Output

Performs the >> operation.

impl Shr<u8> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> Self::Output

Performs the >> operation.

impl Shr<usize> for &Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

impl Shr<usize> for Fixed

type Output = Fixed

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

impl ShrAssign<&i128> for Fixed

fn shr_assign(&mut self, rhs: &i128)

Performs the >>= operation.

impl ShrAssign<&i16> for Fixed

fn shr_assign(&mut self, rhs: &i16)

Performs the >>= operation.

impl ShrAssign<&i32> for Fixed

fn shr_assign(&mut self, rhs: &i32)

Performs the >>= operation.

impl ShrAssign<&i64> for Fixed

fn shr_assign(&mut self, rhs: &i64)

Performs the >>= operation.

impl ShrAssign<&i8> for Fixed

fn shr_assign(&mut self, rhs: &i8)

Performs the >>= operation.

impl ShrAssign<&isize> for Fixed

fn shr_assign(&mut self, rhs: &isize)

Performs the >>= operation.

impl ShrAssign<&u128> for Fixed

fn shr_assign(&mut self, rhs: &u128)

Performs the >>= operation.

impl ShrAssign<&u16> for Fixed

fn shr_assign(&mut self, rhs: &u16)

Performs the >>= operation.

impl ShrAssign<&u32> for Fixed

fn shr_assign(&mut self, rhs: &u32)

Performs the >>= operation.

impl ShrAssign<&u64> for Fixed

fn shr_assign(&mut self, rhs: &u64)

Performs the >>= operation.

impl ShrAssign<&u8> for Fixed

fn shr_assign(&mut self, rhs: &u8)

Performs the >>= operation.

impl ShrAssign<&usize> for Fixed

fn shr_assign(&mut self, rhs: &usize)

Performs the >>= operation.

impl ShrAssign<i128> for Fixed

fn shr_assign(&mut self, rhs: i128)

Performs the >>= operation.

impl ShrAssign<i16> for Fixed

fn shr_assign(&mut self, rhs: i16)

Performs the >>= operation.

impl ShrAssign<i32> for Fixed

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl ShrAssign<i64> for Fixed

fn shr_assign(&mut self, rhs: i64)

Performs the >>= operation.

impl ShrAssign<i8> for Fixed

fn shr_assign(&mut self, rhs: i8)

Performs the >>= operation.

impl ShrAssign<isize> for Fixed

fn shr_assign(&mut self, rhs: isize)

Performs the >>= operation.

impl ShrAssign<u128> for Fixed

fn shr_assign(&mut self, rhs: u128)

Performs the >>= operation.

impl ShrAssign<u16> for Fixed

fn shr_assign(&mut self, rhs: u16)

Performs the >>= operation.

impl ShrAssign<u32> for Fixed

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl ShrAssign<u64> for Fixed

fn shr_assign(&mut self, rhs: u64)

Performs the >>= operation.

impl ShrAssign<u8> for Fixed

fn shr_assign(&mut self, rhs: u8)

Performs the >>= operation.

impl ShrAssign<usize> for Fixed

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl Sub<&Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the - operator.

fn sub(self, rhs: &Fixed) -> Self::Output

Performs the - operation.

impl Sub<&Fixed> for Fixed

type Output = Fixed

The resulting type after applying the - operator.

fn sub(self, rhs: &Fixed) -> Self::Output

Performs the - operation.

impl Sub<Fixed> for &Fixed

type Output = Fixed

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed) -> Self::Output

Performs the - operation.

impl Sub for Fixed

type Output = Fixed

The resulting type after applying the - operator.

fn sub(self, rhs: Fixed) -> Self::Output

Performs the - operation.

impl SubAssign for Fixed

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Fixed

impl Eq for Fixed

impl StructuralPartialEq for Fixed