Enum citadel_sdk::prefabs::client::broadcast::GroupInitRequestType

pub enum GroupInitRequestType {
    Create {
        local_user: UserIdentifier,
        invite_list: Vec<UserIdentifier>,
        group_id: Uuid,
        accept_registrations: bool,
    },
    Join {
        local_user: UserIdentifier,
        owner: UserIdentifier,
        group_id: Uuid,
        do_peer_register: bool,
    },
}

Before running the BroadcastKernel, each peer must send this request to the protocol. One peer can create a group, allowing others to join the group.

Each peer may create multiple groups.

Note: When creating a group, a GroupType::Public will be created. This means any mutually-registered user to the owner may join the group

Variants

Create

Fields

local_user: UserIdentifier

invite_list: Vec<UserIdentifier>

group_id: Uuid

accept_registrations: bool

Create a new group, under owner, with a list of users that are desired to be invited

if accept_registrations is true, then, any inbound registrations will automatically be accepted, simulating a publicly open group to all users on the server.

Join

Fields

local_user: UserIdentifier

owner: UserIdentifier

group_id: Uuid

do_peer_register: bool

Join a pre-existing group as local_user that is administered by owner, and a group_id that corresponds to a unique group administered by the particular owner

Note: ordinarily, local_user must be mutually-register to the owner. However, if do_peer_register is specified, this will ensure both users are registered before continuing (this is not recommended for production environments, since the timing of registration between users should be approximately equal, otherwise, the registration request may expire)

Trait Implementations

impl<'a, F, Fut> PrefabFunctions<'a, GroupInitRequestType> for BroadcastKernel<'a, F, Fut>

where F: FnOnce(GroupChannel, ClientServerRemote) -> Fut + Send + 'a, Fut: Future<Output = Result<(), NetworkError>> + Send + 'a,

type UserLevelInputFunction = F

type SharedBundle = Arc<BroadcastShared>

Shared between the kernel and the on_c2s_channel_received function

fn get_shared_bundle(&self) -> Self::SharedBundle

fn on_c2s_channel_received<'async_trait>( connect_success: ConnectionSuccess, remote: ClientServerRemote, arg: GroupInitRequestType, fx: Self::UserLevelInputFunction, shared: Arc<BroadcastShared> ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>

where Self: 'async_trait,

fn construct(kernel: Box<dyn NetKernel + 'a>) -> Self

fn new_connect<T: Into<String>, P: Into<SecBuffer>>( username: T, password: P, arg: Arg, udp_mode: UdpMode, session_security_settings: SessionSecuritySettings, server_password: Option<PreSharedKey>, on_channel_received: Self::UserLevelInputFunction ) -> Self

Creates a new connection with a central server entailed by the user information

fn new_connect_defaults<T: Into<String>, P: Into<SecBuffer>>( username: T, password: P, arg: Arg, on_channel_received: Self::UserLevelInputFunction ) -> Self

Crates a new connection with a central server entailed by the user information and default configuration

fn new_register<T: Into<String>, R: Into<String>, P: Into<SecBuffer>, V: ToSocketAddrs>( full_name: T, username: R, password: P, arg: Arg, server_addr: V, udp_mode: UdpMode, session_security_settings: SessionSecuritySettings, server_password: Option<PreSharedKey>, on_channel_received: Self::UserLevelInputFunction ) -> Result<Self, NetworkError>

First registers with a central server with the proposed credentials, and thereafter, establishes a connection with custom parameters

fn new_register_defaults<T: Into<String>, R: Into<String>, P: Into<SecBuffer>, V: ToSocketAddrs>( full_name: T, username: R, password: P, arg: Arg, server_addr: V, on_channel_received: Self::UserLevelInputFunction ) -> Result<Self, NetworkError>

First registers with a central server with the proposed credentials, and thereafter, establishes a connection with default parameters

fn new_authless<V: ToSocketAddrs>( uuid: Uuid, server_addr: V, arg: Arg, udp_mode: UdpMode, session_security_settings: SessionSecuritySettings, server_password: Option<PreSharedKey>, on_channel_received: Self::UserLevelInputFunction ) -> Result<Self, NetworkError>

Creates a new authless connection with custom arguments

fn new_authless_defaults<V: ToSocketAddrs>( uuid: Uuid, server_addr: V, arg: Arg, on_channel_received: Self::UserLevelInputFunction ) -> Result<Self, NetworkError>

Creates a new authless connection with default arguments