Enum SignalScope 

pub enum SignalScope {
    Global,
    Channel(ChannelId),
    WithChildren(ChannelId),
}

The scope affected by a signal or permission check.

Defines the boundary of effect for control operations.

Scope Hierarchy

Global
  └── WithChildren (channel + descendants)
        └── Channel (specific only)

Permission Requirements

Scope	Standard Privilege	Elevated Privilege
Global	Denied	Allowed
WithChildren (own)	Allowed	Allowed
WithChildren (other)	Denied	Allowed
Channel (own)	Allowed	Allowed
Channel (other)	Denied	Allowed

Example

use orcs_types::{SignalScope, ChannelId};

let global = SignalScope::Global;
let channel = SignalScope::Channel(ChannelId::new());
let with_children = SignalScope::WithChildren(ChannelId::new());

assert!(global.is_global());
assert!(!channel.is_global());
assert!(with_children.includes_descendants());

Variants

Global

Affects all channels and components.

Requires elevated privilege.

Channel(ChannelId)

Affects a specific channel only.

WithChildren(ChannelId)

Affects a channel and all its descendants.

Use this when you want to signal a subtree of channels. Descendant checking requires World access at runtime.

Implementations

impl SignalScope

pub fn is_global(&self) -> bool

Returns true if this is a Global scope.

Example

use orcs_types::SignalScope;

assert!(SignalScope::Global.is_global());

pub fn includes_descendants(&self) -> bool

Returns true if this scope includes descendants.

Both Global and WithChildren include descendants.

Example

use orcs_types::{SignalScope, ChannelId};

assert!(SignalScope::Global.includes_descendants());
assert!(SignalScope::WithChildren(ChannelId::new()).includes_descendants());
assert!(!SignalScope::Channel(ChannelId::new()).includes_descendants());

pub fn affects(&self, channel: ChannelId) -> bool

Returns true if this scope affects the given channel (without descendant check).

For WithChildren, this only checks the root channel. Use affects_with_descendants() for full descendant checking.

Example

use orcs_types::{SignalScope, ChannelId};

let ch1 = ChannelId::new();
let ch2 = ChannelId::new();

assert!(SignalScope::Global.affects(ch1));
assert!(SignalScope::Channel(ch1).affects(ch1));
assert!(!SignalScope::Channel(ch1).affects(ch2));

pub fn affects_with_descendants<F>( &self, channel: ChannelId, is_descendant: F, ) -> bool

where F: FnOnce(ChannelId) -> bool,

Checks if this scope affects the given channel, with descendant support.

The is_descendant closure is called for WithChildren scope to check if the channel is a descendant of the scope’s root.

Arguments

• channel - The channel to check
• is_descendant - Closure that returns true if channel is a descendant of the scope root

Example

use orcs_types::{SignalScope, ChannelId};

let root = ChannelId::new();
let child = ChannelId::new();
let other = ChannelId::new();

let scope = SignalScope::WithChildren(root);

// Simulate: child is descendant of root, other is not
assert!(scope.affects_with_descendants(root, |_| false)); // root itself
assert!(scope.affects_with_descendants(child, |ch| ch == child)); // child
assert!(!scope.affects_with_descendants(other, |_| false)); // unrelated

pub fn channel(&self) -> Option<ChannelId>

Returns the target channel if this is a Channel or WithChildren scope.

Trait Implementations

impl Clone for SignalScope

fn clone(&self) -> SignalScope

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SignalScope

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SignalScope

fn deserialize<__D>( __deserializer: __D, ) -> Result<SignalScope, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SignalScope

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

Formats the value using the given formatter.

impl Eq for SignalScope

impl PartialEq for SignalScope

fn eq(&self, other: &SignalScope) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SignalScope

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SignalScope