Struct CompositionPolicy 

pub struct CompositionPolicy<R = SequentialReadPolicy, W = OptimisticParallelWritePolicy>
where
    R: CompositionReadPolicy,
    W: CompositionWritePolicy,
{ /* private fields */ }

Bundle of read, write, and refill policies for CompositionBackend.

This struct provides a builder pattern for configuring all three policy types together, making it easy to create and reuse policy configurations.

Example

use hitbox_backend::composition::{CompositionPolicy, CompositionBackend};
use hitbox_backend::composition::policy::{RaceReadPolicy, SequentialWritePolicy, RefillPolicy};

let policy = CompositionPolicy::new()
    .read(RaceReadPolicy::new())
    .write(SequentialWritePolicy::new())
    .refill(RefillPolicy::Always);

let backend = CompositionBackend::new(l1, l2)
    .with_policy(policy);

Implementations

impl CompositionPolicy<SequentialReadPolicy, OptimisticParallelWritePolicy>

pub fn new() -> Self

Create a new policy bundle with default policies.

Default policies:

• Read: SequentialReadPolicy (try L1 first, then L2)
• Write: OptimisticParallelWritePolicy (write to both, succeed if ≥1 succeeds)
• Refill: RefillPolicy::Never (do not populate L1 after L2 hit)

impl<R, W> CompositionPolicy<R, W>

where R: CompositionReadPolicy, W: CompositionWritePolicy,

pub fn read<NewR: CompositionReadPolicy>( self, read: NewR, ) -> CompositionPolicy<NewR, W>

Set the read policy (builder pattern).

Example

use hitbox_backend::composition::CompositionPolicy;
use hitbox_backend::composition::policy::RaceReadPolicy;

let policy = CompositionPolicy::new()
    .read(RaceReadPolicy::new());

pub fn write<NewW: CompositionWritePolicy>( self, write: NewW, ) -> CompositionPolicy<R, NewW>

Set the write policy (builder pattern).

Example

use hitbox_backend::composition::CompositionPolicy;
use hitbox_backend::composition::policy::SequentialWritePolicy;

let policy = CompositionPolicy::new()
    .write(SequentialWritePolicy::new());

pub fn refill(self, refill: RefillPolicy) -> CompositionPolicy<R, W>

Set the refill policy (builder pattern).

Example

use hitbox_backend::composition::CompositionPolicy;
use hitbox_backend::composition::policy::RefillPolicy;

let policy = CompositionPolicy::new()
    .refill(RefillPolicy::Always);

pub fn read_policy(&self) -> &R

Get a reference to the read policy.

pub fn write_policy(&self) -> &W

Get a reference to the write policy.

pub fn refill_policy(&self) -> &RefillPolicy

Get a reference to the refill policy.

Trait Implementations

impl<R, W> Clone for CompositionPolicy<R, W>

where R: CompositionReadPolicy + Clone, W: CompositionWritePolicy + Clone,

fn clone(&self) -> CompositionPolicy<R, W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R, W> Debug for CompositionPolicy<R, W>

where R: CompositionReadPolicy + Debug, W: CompositionWritePolicy + Debug,

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

Formats the value using the given formatter.

impl Default for CompositionPolicy<SequentialReadPolicy, OptimisticParallelWritePolicy>

fn default() -> Self

Returns the “default value” for a type.