Struct r3_kernel::System

pub struct System<Traits>(_);

Wraps a provided trait type Traits to instantiate a kernel. This type implements the traits from r3_core::kernel::raw, making it usable as a kernel, if Traits implements some appropriate traits, which consequently make it implement KernelTraits.

Trait Implementations

impl<Traits> Clone for System<Traits>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Traits> Debug for System<Traits>

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

Formats the value using the given formatter.

impl<Traits: KernelStatic<System<Traits>>> DelegateKernelStatic<System<Traits>> for System<Traits>

Implement KernelStatic<System<Traits>> on System<Traits> if the same trait is implemented on Traits.

type Target = Traits

impl<Traits: KernelTraits> KernelAdjustTime for System<Traits>

const RAW_TIME_USER_HEADROOM: Duration = TIME_USER_HEADROOM

Implements Kernel::time_user_headroom.

fn raw_adjust_time(delta: Duration) -> Result<(), AdjustTimeError>

Implements Kernel::adjust_time.

impl<Traits: KernelTraits> KernelBase for System<Traits>

fn raw_debug() -> Self::RawDebugPrinter

Get an object that implements Debug for dumping the current kernel state.

Note that printing this object might consume a large amount of stack space.

const RAW_SUPPORTED_QUEUE_ORDERS: &'static [Option<QueueOrderKind>] = _

Used by QueueOrder::is_supported.

fn raw_acquire_cpu_lock() -> Result<(), CpuLockError>

Implements Kernel::acquire_cpu_lock.

unsafe fn raw_release_cpu_lock() -> Result<(), CpuLockError>

Implements Kernel::release_cpu_lock.

fn raw_has_cpu_lock() -> bool

Return a flag indicating whether CPU Lock is currently active.

unsafe fn raw_unboost_priority() -> Result<(), BoostPriorityError>

Implements Kernel::unboost_priority.

fn raw_is_priority_boost_active() -> bool

Implements Kernel::is_priority_boost_active.

fn raw_is_task_context() -> bool

Implements Kernel::is_task_context.

fn raw_is_interrupt_context() -> bool

Implements Kernel::is_interrupt_context.

fn raw_is_boot_complete() -> bool

Implements Kernel::is_boot_complete.

fn raw_set_time(time: Time) -> Result<(), TimeError>

Implements Kernel::set_time.

unsafe fn raw_exit_task() -> Result<!, ExitTaskError>

Implements Kernel::exit_task.

fn raw_park() -> Result<(), ParkError>

Implements Kernel::park.

fn raw_park_timeout(timeout: Duration) -> Result<(), ParkTimeoutError>

Implements Kernel::park_timeout.

fn raw_sleep(timeout: Duration) -> Result<(), SleepError>

Implements Kernel::sleep.

type RawDebugPrinter = KernelDebugPrinter<Traits>

type RawTaskId = NonZeroUsize

The type to identify tasks.

fn raw_task_current() -> Result<Self::RawTaskId, GetCurrentTaskError>

Get the current task.

unsafe fn raw_task_activate(
    this: Self::RawTaskId
) -> Result<(), ActivateTaskError>

Implements Task::activate.

unsafe fn raw_task_interrupt(
    this: Self::RawTaskId
) -> Result<(), InterruptTaskError>

Implements Task::interrupt.

unsafe fn raw_task_unpark_exact(
    this: Self::RawTaskId
) -> Result<(), UnparkExactError>

Implements Task::unpark_exact.

unsafe fn raw_task_priority(
    this: Self::RawTaskId
) -> Result<usize, GetTaskPriorityError>

Implements Task::priority.

unsafe fn raw_task_effective_priority(
    this: Self::RawTaskId
) -> Result<usize, GetTaskPriorityError>

Implements Task::effective_priority.

impl<Traits: KernelTraits> KernelBoostPriority for System<Traits>

Available on crate feature priority_boost only.

fn raw_boost_priority() -> Result<(), BoostPriorityError>

Implements Kernel::boost_priority.

impl<Traits: KernelTraits> KernelEventGroup for System<Traits>

type RawEventGroupId = NonZeroUsize

The type to identify event groups.

unsafe fn raw_event_group_set(
    this: Id,
    bits: EventGroupBits
) -> Result<(), UpdateEventGroupError>

Implements EventGroup::set.

unsafe fn raw_event_group_clear(
    this: Id,
    bits: EventGroupBits
) -> Result<(), UpdateEventGroupError>

Implements EventGroup::clear.

unsafe fn raw_event_group_get(
    this: Id
) -> Result<EventGroupBits, GetEventGroupError>

Implements EventGroup::get.

unsafe fn raw_event_group_wait(
    this: Id,
    bits: EventGroupBits,
    flags: EventGroupWaitFlags
) -> Result<EventGroupBits, WaitEventGroupError>

Implements EventGroup::wait.

unsafe fn raw_event_group_wait_timeout(
    this: Id,
    bits: EventGroupBits,
    flags: EventGroupWaitFlags,
    timeout: Duration
) -> Result<EventGroupBits, WaitEventGroupTimeoutError>

Implements EventGroup::wait_timeout.

unsafe fn raw_event_group_poll(
    this: Id,
    bits: EventGroupBits,
    flags: EventGroupWaitFlags
) -> Result<EventGroupBits, PollEventGroupError>

Implements EventGroup::poll.

impl<Traits: KernelTraits> KernelInterruptLine for System<Traits>

const RAW_MANAGED_INTERRUPT_PRIORITY_RANGE: Range<InterruptPriority> = <Traits as PortInterrupts>::MANAGED_INTERRUPT_PRIORITY_RANGE

The range of interrupt priority values considered managed.

const RAW_MANAGED_INTERRUPT_LINES: &'static [InterruptNum] = <Traits as PortInterrupts>::MANAGED_INTERRUPT_LINES

The list of interrupt lines which are considered managed.

unsafe fn raw_interrupt_line_set_priority(
    this: InterruptNum,
    value: InterruptPriority
) -> Result<(), SetInterruptLinePriorityError>

Implements InterruptLine::set_priority.

unsafe fn raw_interrupt_line_enable(
    this: InterruptNum
) -> Result<(), EnableInterruptLineError>

Implements InterruptLine::enable.

unsafe fn raw_interrupt_line_disable(
    this: InterruptNum
) -> Result<(), EnableInterruptLineError>

Implements InterruptLine::disable.

unsafe fn raw_interrupt_line_pend(
    this: InterruptNum
) -> Result<(), PendInterruptLineError>

Implements InterruptLine::pend.

unsafe fn raw_interrupt_line_clear(
    this: InterruptNum
) -> Result<(), ClearInterruptLineError>

Implements InterruptLine::clear.

unsafe fn raw_interrupt_line_is_pending(
    this: InterruptNum
) -> Result<bool, QueryInterruptLineError>

Implements InterruptLine::is_pending.

impl<Traits: KernelTraits> KernelMutex for System<Traits>

type RawMutexId = NonZeroUsize

The type to identify mutexes.

const RAW_SUPPORTED_MUTEX_PROTOCOLS: &'static [Option<MutexProtocolKind>] = _

Used by MutexProtocol::is_supported.

unsafe fn raw_mutex_is_locked(this: Id) -> Result<bool, QueryMutexError>

Implements Mutex::is_locked.

unsafe fn raw_mutex_unlock(this: Id) -> Result<(), UnlockMutexError>

Implements Mutex::unlock.

unsafe fn raw_mutex_lock(this: Id) -> Result<(), LockMutexError>

Implements Mutex::lock.

unsafe fn raw_mutex_lock_timeout(
    this: Id,
    timeout: Duration
) -> Result<(), LockMutexTimeoutError>

Implements Mutex::lock_timeout.

unsafe fn raw_mutex_try_lock(this: Id) -> Result<(), TryLockMutexError>

Implements Mutex::try_lock.

unsafe fn raw_mutex_mark_consistent(
    this: Id
) -> Result<(), MarkConsistentMutexError>

Implements Mutex::mark_consistent.

impl<Traits: KernelTraits> KernelSemaphore for System<Traits>

type RawSemaphoreId = NonZeroUsize

The type to identify semaphores.

unsafe fn raw_semaphore_drain(this: Id) -> Result<(), DrainSemaphoreError>

Implements Semaphore::drain.

unsafe fn raw_semaphore_get(
    this: Id
) -> Result<SemaphoreValue, GetSemaphoreError>

Implements Semaphore::get.

unsafe fn raw_semaphore_signal(
    this: Id,
    count: SemaphoreValue
) -> Result<(), SignalSemaphoreError>

Implements Semaphore::signal.

unsafe fn raw_semaphore_signal_one(this: Id) -> Result<(), SignalSemaphoreError>

Implements Semaphore::signal_one.

unsafe fn raw_semaphore_wait_one(this: Id) -> Result<(), WaitSemaphoreError>

Implements Semaphore::wait_one.

unsafe fn raw_semaphore_wait_one_timeout(
    this: Id,
    timeout: Duration
) -> Result<(), WaitSemaphoreTimeoutError>

Implements Semaphore::wait_one_timeout.

unsafe fn raw_semaphore_poll_one(this: Id) -> Result<(), PollSemaphoreError>

Implements Semaphore::poll_one.

impl<Traits: KernelTraits> KernelTaskSetPriority for System<Traits>

unsafe fn raw_task_set_priority(
    this: Self::RawTaskId,
    priority: usize
) -> Result<(), SetTaskPriorityError>

Implements Task::set_priority.

impl<Traits: KernelTraits> KernelTime for System<Traits>

Available on crate feature system_time only.

fn raw_time() -> Result<Time, TimeError>

Implements Kernel::time.

impl<Traits: KernelTraits> KernelTimer for System<Traits>

type RawTimerId = NonZeroUsize

The type to identify timers.

unsafe fn raw_timer_start(this: Id) -> Result<(), StartTimerError>

Implements Timer::start.

unsafe fn raw_timer_stop(this: Id) -> Result<(), StopTimerError>

Implements Timer::stop.

unsafe fn raw_timer_set_delay(
    this: Id,
    delay: Option<Duration>
) -> Result<(), SetTimerDelayError>

Implements Timer::set_delay.

unsafe fn raw_timer_set_period(
    this: Id,
    period: Option<Duration>
) -> Result<(), SetTimerPeriodError>

Implements Timer::set_period.

impl<Traits> Copy for System<Traits>