Quelle  options.rs

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

//! Different options for the marker API.
//! See [`MarkerOptions`] and its fields.

use crate::gecko_bindings::{bindings, structs::mozilla};
use crate::ProfilerTime;
use std::mem::MaybeUninit;

/// Marker option that contains marker timing information.
/// This class encapsulates the logic for correctly storing a marker based on its
/// constructor types. Use the static methods to create the MarkerTiming. This is
/// a transient object that is being used to enforce the constraints of the
/// combinations of the data.
///
/// Implementation details: This is a RAII object that constructs and destroys a
/// C++ MarkerTiming object pointed to a specified reference. It allocates the
/// marker timing on stack and it's safe to move around because it's a
/// trivially-copyable object that only contains a few numbers.
#[derive(Debug)]
pub struct MarkerTiming(pub(crate) MaybeUninit<mozilla::MarkerTiming>);

impl MarkerTiming {
    /// Instant marker timing at a specific time.
    pub fn instant_at(time: ProfilerTime) -> MarkerTiming {
        let mut marker_timing = MaybeUninit::<mozilla::MarkerTiming>::uninit();
        unsafe {
            bindings::gecko_profiler_construct_marker_timing_instant_at(
                marker_timing.as_mut_ptr(),
                &time.0,
            );
        }
        MarkerTiming(marker_timing)
    }

    /// Instant marker timing at this time.
    pub fn instant_now() -> MarkerTiming {
        let mut marker_timing = MaybeUninit::<mozilla::MarkerTiming>::uninit();
        unsafe {
            bindings::gecko_profiler_construct_marker_timing_instant_now(
                marker_timing.as_mut_ptr(),
            );
        }
        MarkerTiming(marker_timing)
    }

    /// Interval marker timing with start and end times.
    pub fn interval(start_time: ProfilerTime, end_time: ProfilerTime) -> MarkerTiming {
        let mut marker_timing = MaybeUninit::<mozilla::MarkerTiming>::uninit();
        unsafe {
            bindings::gecko_profiler_construct_marker_timing_interval(
                marker_timing.as_mut_ptr(),
                &start_time.0,
                &end_time.0,
            );
        }
        MarkerTiming(marker_timing)
    }

    /// Interval marker with a start time and end time as "now".
    pub fn interval_until_now_from(start_time: ProfilerTime) -> MarkerTiming {
        let mut marker_timing = MaybeUninit::<mozilla::MarkerTiming>::uninit();
        unsafe {
            bindings::gecko_profiler_construct_marker_timing_interval_until_now_from(
                marker_timing.as_mut_ptr(),
                &start_time.0,
            );
        }
        MarkerTiming(marker_timing)
    }

    /// Interval start marker with only start time. This is a partial marker and
    /// it requires another marker with `instant_end` to be complete.
    pub fn interval_start(time: ProfilerTime) -> MarkerTiming {
        let mut marker_timing = MaybeUninit::<mozilla::MarkerTiming>::uninit();
        unsafe {
            bindings::gecko_profiler_construct_marker_timing_interval_start(
                marker_timing.as_mut_ptr(),
                &time.0,
            );
        }
        MarkerTiming(marker_timing)
    }

    /// Interval end marker with only end time. This is a partial marker and
    /// it requires another marker with `interval_start` to be complete.
    pub fn interval_end(time: ProfilerTime) -> MarkerTiming {
        let mut marker_timing = MaybeUninit::<mozilla::MarkerTiming>::uninit();
        unsafe {
            bindings::gecko_profiler_construct_marker_timing_interval_end(
                marker_timing.as_mut_ptr(),
                &time.0,
            );
        }
        MarkerTiming(marker_timing)
    }
}

impl Default for MarkerTiming {
    fn default() -> Self {
        MarkerTiming::instant_now()
    }
}

impl Drop for MarkerTiming {
    fn drop(&mut self) {
        unsafe {
            bindings::gecko_profiler_destruct_marker_timing(self.0.as_mut_ptr());
        }
    }
}

/// Marker option that contains marker stack information.
pub type MarkerStack = mozilla::StackCaptureOptions;

impl Default for MarkerStack {
    fn default() -> Self {
        MarkerStack::NoStack
    }
}

/// This class combines each of the possible marker options above.
/// Use Default::default() for the options that you don't want to provide or the
/// options you want to leave as default. Example usage:
///
/// ```rust
///  MarkerOptions {
///     timing: MarkerTiming::instant_now(),
///     ..Default::default()
///  }
/// ```
#[derive(Debug, Default)]
pub struct MarkerOptions {
    pub timing: MarkerTiming,
    pub stack: MarkerStack,
}

impl MarkerOptions {
    /// Given an existing marker option, update the timing member and return a
    /// new MarkerOptions. This is a helper method to allow:
    /// `
    ///     add_marker(
    ///         name,
    ///         category,
    ///         options_from_elsewhere.with_timing(new_timings),
    ///         payload,
    ///     );
    /// `
    /// rather than the more verbose:
    /// `
    ///     let new_options = options_from_elsewhere;
    ///     new_options.timing = new_timings;
    ///     add_marker(
    ///         name,
    ///         category,
    ///         new_options,
    ///         payload,
    ///     );
    /// `
    pub fn with_timing(&self, timing: MarkerTiming) -> Self {
        MarkerOptions {
            timing,
            stack: self.stack,
        }
    }
}