Struct KnowledgeCandidates 

pub struct KnowledgeCandidates {
    pub total: usize,
    pub on_this_branch: usize,
    pub unattributed: usize,
    pub branch: String,
    pub candidates: Vec<KnowledgeCandidate>,
    pub groups: Vec<KnowledgeGroup>,
    pub cap: Option<usize>,
    pub over_cap: bool,
    pub findings: Vec<String>,
}

The candidates awaiting review, against the policy’s cap.

use majordomus_cli::capability::builtin::knowledge_base::KnowledgeCandidates;
let empty: KnowledgeCandidates = serde_json::from_str(
    r#"{"total":0,"on_this_branch":0,"unattributed":0,"branch":"master","candidates":[],"over_cap":false}"#,
).unwrap();
assert_eq!(empty.total, 0, "an empty queue is an answer");
assert_eq!(empty.cap, None, "and a policy without the key declares no cap");

Fields

total: usize

How many records carry status: candidate under the candidates class.

on_this_branch: usize

How many of them came from an episode on this checkout’s branch.

unattributed: usize

How many name an episode this checkout knows nothing about.

branch: String

The branch this answer is about, or DETACHED.

candidates: Vec<KnowledgeCandidate>

Every candidate, in canonical order of id.

groups: Vec<KnowledgeGroup>

The candidates and rejected records derived from observations, grouped by what they are about, in order of subject.

cap: Option<usize>

knowledge.candidates_max_files, when the policy declares it.

over_cap: bool

True when total exceeds cap. False when no cap is declared: nobody wrote one down.

findings: Vec<String>

What a reader should know before trusting the above: a malformed record that was skipped, a cap that was exceeded, a policy that declares none. Empty is the good case.

Trait Implementations

impl Clone for KnowledgeCandidates

fn clone(&self) -> KnowledgeCandidates

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KnowledgeCandidates

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KnowledgeCandidates

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for KnowledgeCandidates

impl JsonSchema for KnowledgeCandidates

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for KnowledgeCandidates

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for KnowledgeCandidates