Struct PackPlan 

pub struct PackPlan {

    pub measured: bool,
    pub reason: Option<String>,
    pub profile: String,
    pub commit: Option<String>,
    pub index_matches_head: bool,
    pub tracked: usize,
    pub selected: usize,
    pub bytes: u64,
    pub tokens: u64,
    pub tokenizer: String,
    pub limits: Option<ShardLimits>,
    pub dropped: BTreeMap<String, usize>,
    pub dropped_files: Vec<DroppedFile>,
    pub shards: Vec<ShardPlan>,
    pub findings: Vec<PackFinding>,
    pub passes: bool,
}

The plan of one pack: what it carries, what it leaves out and why, how it is cut into shards, and whether it may be built.

The examples below plan a repository holding main.rs and a logo.png whose content is binary, with a distribution whose chat profile has limits and whose bare one has none.

use majordomus_cli::pack::{plan, PackPlan};
let p: PackPlan = plan(&root, &share, None).plan;
assert!(p.measured && p.passes && p.index_matches_head);
assert_eq!((p.tracked, p.selected), (2, 1));
assert_eq!(p.dropped["binary"], 1);
// an unknown profile is not measured, and not measured is never a pass
let p: PackPlan = plan(&root, &share, Some("nope")).plan;
assert!(!p.measured && !p.passes);

Fields

measured: bool

Whether the tree could be read at all. false is not a pass.

reason: Option<String>

Why it could not, when it could not.

profile: String

The profile planned.

commit: Option<String>

The commit HEAD names; the content is the index’s, which equals it when index_matches_head is true.

index_matches_head: bool

Whether the index holds exactly what HEAD holds. false means staged changes travel with the pack under a commit id that does not contain them.

tracked: usize

How many files the index tracks.

selected: usize

How many the pack carries.

bytes: u64

The bytes of the content carried.

tokens: u64

The tokens of the content carried, in o200k_base.

tokenizer: String

The tokenizer the counts are in.

limits: Option<ShardLimits>

The limits applied.

dropped: BTreeMap<String, usize>

How many files were left out, by reason.

dropped_files: Vec<DroppedFile>

Every file left out for a reason other than derived.

shards: Vec<ShardPlan>

The shards, in order; the index is not one of them.

findings: Vec<PackFinding>

Every reason the pack cannot be built. Empty is the passing answer.

passes: bool

true when the tree was measured and nothing was found.

Trait Implementations

impl Clone for PackPlan

fn clone(&self) -> PackPlan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PackPlan

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PackPlan

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for PackPlan

impl JsonSchema for PackPlan

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 PackPlan

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

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 PackPlan