Struct CommandRequest 

pub struct CommandRequest {
    pub request_id: CommandRequestId,
    pub expected_revision: u64,
    pub envelope: CommandEnvelope,
}

Fields

request_id: CommandRequestId

expected_revision: u64

Must equal the persisted authoritative revision at command admission.

Accepted commands, persisted expected rejections, and completed settlement boundaries advance the revision. Bare clock movement does not, so declared external commands also carry envelope.expected_time.

envelope: CommandEnvelope

Implementations

impl CommandRequest

pub const fn new( request_id: CommandRequestId, expected_revision: u64, envelope: CommandEnvelope, ) -> CommandRequest

Examples found in repository

examples/continuous_game_loop.rs (lines 275-279)

    fn submit_player_command(&mut self) -> Result<(), CanwuError> {
        let captured_at = self.presentation_time();
        let due_at = if self.accumulated_sim_nanos == 0 {
            self.authority.time()
        } else {
            self.authority
                .time()
                .checked_add(SIMULATION_QUANTUM)
                .expect("the scripted command time must remain representable")
        };
        let envelope = CommandEnvelope::new(
            Issuer::Actor(self.ids.commander),
            Command::MoveArmy {
                army: self.ids.army,
                destination: self.ids.eastern_territory,
            },
        )
        .at_time(due_at);
        let request = CommandRequest::new(
            CommandRequestId::new(1),
            self.authority.revision(),
            envelope,
        );
        let ingress = self.authority.enqueue_command(due_at, 0, request)?;

        if self.verbose {
            println!(
                "INPUT: queued commander move as {:?}, captured_at={captured_at}, quantized_due_at={due_at}",
                ingress.ingress_id,
            );
        }

        // This drains ingress due at the current canonical time only. The
        // mid-quantum command remains queued until normal accumulation reaches
        // its quantized minute; future scheduled work is never jumped to.
        let receipts = self.authority.advance_canonical(SimDuration::ZERO)?;
        self.canonical_boundaries += receipts.len();
        self.refresh_presentation_from_authority();
        self.presentation.render(self.presentation_time());
        if self.verbose {
            self.print_frame(GameSpeed::X1);
        }
        self.report_new_events();
        Ok(())
    }

Trait Implementations

impl Clone for CommandRequest

fn clone(&self) -> CommandRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CommandRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CommandRequest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for CommandRequest

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CommandRequest

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 CommandRequest