Struct StyleRegistry 

#[non_exhaustive]
pub struct StyleRegistry {
    pub fonts: Vec<FontId>,
    pub char_shapes: Vec<CharShape>,
    pub para_shapes: Vec<ParaShape>,
    pub style_entries: IndexMap<String, StyleEntry>,
}

A registry of resolved styles with index-based access.

After inheritance resolution, the Template is converted into a StyleRegistry where every style is assigned numeric indices for efficient lookup during document rendering.

Font Deduplication

Multiple styles can reference the same font. The registry deduplicates fonts automatically:

// Two styles with the same font → single FontIndex
styles:
  body: { font: "Batang", size: 10pt }
  heading: { font: "Batang", size: 16pt }

// Registry: fonts = ["Batang"] (index 0)
//           char_shapes[0].font_id = FontIndex(0)
//           char_shapes[1].font_id = FontIndex(0)

Index Allocation

Indices are allocated sequentially in the order styles appear in the template (preserving YAML field order via IndexMap):

• CharShape 0, CharShape 1, CharShape 2…
• ParaShape 0, ParaShape 1, ParaShape 2…
• Font 0, Font 1… (deduplicated)

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

fonts: Vec<FontId>

All unique fonts referenced by character shapes.

char_shapes: Vec<CharShape>

All resolved character shapes.

para_shapes: Vec<ParaShape>

All resolved paragraph shapes.

style_entries: IndexMap<String, StyleEntry>

Mapping from style name to its indices (insertion-order preserved).

Implementations

impl StyleRegistry

pub fn from_template(template: &Template) -> BlueprintResult<Self>

Creates a StyleRegistry from a Template.

This is the final resolution step:

1. Iterate over template styles (in order)
2. Resolve each PartialStyle → CharShape + ParaShape
3. Deduplicate fonts
4. Allocate sequential indices

Errors

• BlueprintError::EmptyStyleMap if the template has no styles
• BlueprintError::StyleResolution if any style is missing required fields

Examples

use hwpforge_blueprint::{Template, StyleRegistry};

let template = Template::from_yaml(yaml)?;
let registry = StyleRegistry::from_template(&template)?;

// Access by name
let body_entry = registry.get_style("body").unwrap();
let char_shape = registry.char_shape(body_entry.char_shape_id).unwrap();
assert_eq!(char_shape.font, "한컴바탕");

pub fn get_style(&self, name: &str) -> Option<&StyleEntry>

Looks up a style by name.

Returns None if the style name does not exist.

pub fn char_shape(&self, idx: CharShapeIndex) -> Option<&CharShape>

Retrieves a character shape by index.

Returns None if the index is out of bounds.

pub fn para_shape(&self, idx: ParaShapeIndex) -> Option<&ParaShape>

Retrieves a paragraph shape by index.

Returns None if the index is out of bounds.

pub fn font(&self, idx: FontIndex) -> Option<&FontId>

Retrieves a font by index.

Returns None if the index is out of bounds.

pub fn font_count(&self) -> usize

Returns the number of unique fonts.

pub fn char_shape_count(&self) -> usize

Returns the number of character shapes.

pub fn para_shape_count(&self) -> usize

Returns the number of paragraph shapes.

pub fn style_count(&self) -> usize

Returns the number of named styles.

Trait Implementations

impl Clone for StyleRegistry

fn clone(&self) -> StyleRegistry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StyleRegistry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StyleRegistry

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for StyleRegistry

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 StyleRegistry

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

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 StyleRegistry