Struct PermutationSpace 

pub struct PermutationSpace {
    slots: Vec<SlotCandidates>,
    contested_indices: Vec<usize>,
    total: u64,
    contested_count: u32,
    total_candidates: u32,
}

Cartesian product space.

Fields

slots: Vec<SlotCandidates>

contested_indices: Vec<usize>

total: u64

contested_count: u32

total_candidates: u32

Implementations

impl PermutationSpace

pub fn validate(&self) -> Result<(), PermutationError>

Validate all structural and derived invariants.

Errors

Returns an error for empty or oversized candidate sets and inconsistent derived fields. Cardinalities not exactly representable by the JavaScript API are also rejected.

pub fn slots(&self) -> &[SlotCandidates]

pub fn contested_indices(&self) -> &[usize]

pub const fn total(&self) -> u64

pub const fn contested_count(&self) -> u32

pub const fn total_candidates(&self) -> u32

pub fn decode(&self, index: u64) -> Vec<u8>

Mixed-radix decode of a combination index.

pub fn encode(&self, choices: &[u8]) -> u64

Encode per-slot choices to a combination index.

pub fn picks(&self, index: u64) -> Vec<(GearSlot, &Candidate)>

Full item picks for a combination index.

pub fn contested_slots(&self) -> Vec<&SlotCandidates>

Trait Implementations

impl Clone for PermutationSpace

fn clone(&self) -> PermutationSpace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PermutationSpace

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PermutationSpace

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PermutationSpace

fn eq(&self, other: &PermutationSpace) -> 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 Serialize for PermutationSpace

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Tsify for PermutationSpace

const DECL: &'static str = "/**\n * Cartesian product space.\n */\nexport interface PermutationSpace {\n slots: SlotCandidates[];\n contestedIndices: number[];\n total: number;\n contestedCount: number;\n totalCandidates: number;\n}"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

impl StructuralPartialEq for PermutationSpace