Struct Rules 

pub struct Rules {
    pub cache: HashMap<Variable, HashSet<(Client, RatPubRegisterKind)>>,
    /* private fields */
}

Fields

cache: HashMap<Variable, HashSet<(Client, RatPubRegisterKind)>>

Implementations

impl Rules

pub fn new() -> Self

pub fn insert(&mut self, variable: String, strategies: Vec<VariableHuman>)

pub fn new_id(&mut self) -> u32

pub fn remove_client(&mut self, client: &str)

Removes a client (ship) from the rules and cache.

• If the client is the ship performing a Shoot, Catch, Sail, or None action, the entire rule is removed but if there is another partner like in catch or shoot, the partner will be put into the cache with a subscriber/publisher state based on if was receiving it (subscriber) or sending it and the removing client wanted to catch it (publisher)
• If the client is a target in a Shoot action, it is removed from the target list. If the list becomes empty, the Shoot rule is removed, AND the shooter ship is registered as a publisher in the cache.
• Any cache registrations for the client are removed.

pub fn clear(&mut self)

pub fn raw(&self) -> &HashMap<String, Vec<VariableHuman>>

pub fn resolve_cache(&mut self)

Resolves cache entries into rules in the store based on existing rules and new registrations. Generates only Shoot actions, never Catch actions.

• If a variable exists in the store AND has existing Shoot rules, cache registrations for that variable are used to update/regenerate the Shoot rules based on the combined set of publishers and subscribers from the store and cache. The cache entry is removed.
• If a variable is NOT in the store, OR is in the store but lacks Shoot rules, it requires a publisher/subscriber pair within the cache to generate new Shoot rules. These are added (either to a new entry or by extending a non-Shoot entry in the store). If no pair exists in the cache, the cache entry remains.

pub fn register( &mut self, var: String, client: String, kind: RatPubRegisterKind, )

Trait Implementations

impl Clone for Rules

fn clone(&self) -> Rules

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rules

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

Formats the value using the given formatter.

impl Default for Rules

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Rules

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Rules

impl StructuralPartialEq for Rules