Struct Document 

pub struct Document<S = Draft> { /* private fields */ }

The document aggregate root with compile-time state tracking.

The generic parameter S determines which operations are available:

State	Mutable	Serializable	Exportable
Draft	Yes	Yes	No (must validate first)
Validated	No	Yes	Yes

Typestate Safety

The _state field is private and zero-sized. There is no way to construct a Document<Validated> except through validate().

Examples

use hwpforge_core::document::Document;
use hwpforge_core::Metadata;

let doc = Document::with_metadata(Metadata {
    title: Some("Report".to_string()),
    ..Metadata::default()
});
assert!(doc.is_empty());

Implementations

impl<S> Document<S>

pub fn sections(&self) -> &[Section]

Returns a slice of all sections.

Examples

use hwpforge_core::document::Document;

let doc = Document::new();
assert!(doc.sections().is_empty());

pub fn metadata(&self) -> &Metadata

Returns a reference to the document metadata.

pub fn section_count(&self) -> usize

Returns the number of sections.

pub fn is_empty(&self) -> bool

Returns true if the document has no sections.

impl Document<Draft>

pub fn new() -> Self

Creates a new empty draft document with default metadata.

Examples

use hwpforge_core::document::Document;

let doc = Document::new();
assert!(doc.is_empty());

pub fn with_metadata(metadata: Metadata) -> Self

Creates a new draft document with the given metadata.

Examples

use hwpforge_core::document::Document;
use hwpforge_core::Metadata;

let doc = Document::with_metadata(Metadata {
    title: Some("Test".to_string()),
    ..Metadata::default()
});
assert_eq!(doc.metadata().title.as_deref(), Some("Test"));

pub fn add_section(&mut self, section: Section)

Appends a section to the draft document.

Examples

use hwpforge_core::document::Document;
use hwpforge_core::section::Section;
use hwpforge_core::PageSettings;

let mut doc = Document::new();
doc.add_section(Section::new(PageSettings::a4()));
assert_eq!(doc.section_count(), 1);

pub fn set_metadata(&mut self, metadata: Metadata)

Sets the document metadata.

pub fn metadata_mut(&mut self) -> &mut Metadata

Returns a mutable reference to the metadata.

pub fn sections_mut(&mut self) -> &mut [Section]

Returns a mutable slice of sections.

pub fn validate(self) -> CoreResult<Document<Validated>>

Validates the document structure and transitions to Validated.

Consumes self (move semantics). On success, returns a Document<Validated>. On failure, returns a CoreError.

Errors

Returns CoreError::Validation if the document violates any structural invariant (empty sections, empty paragraphs, etc.).

Examples

use hwpforge_core::document::Document;
use hwpforge_core::section::Section;
use hwpforge_core::paragraph::Paragraph;
use hwpforge_core::run::Run;
use hwpforge_core::PageSettings;
use hwpforge_foundation::{CharShapeIndex, ParaShapeIndex};

let mut doc = Document::new();
doc.add_section(Section::with_paragraphs(
    vec![Paragraph::with_runs(
        vec![Run::text("Hello", CharShapeIndex::new(0))],
        ParaShapeIndex::new(0),
    )],
    PageSettings::a4(),
));

let validated = doc.validate().unwrap();
assert_eq!(validated.section_count(), 1);

use hwpforge_core::document::Document;

let doc = Document::new(); // empty
assert!(doc.validate().is_err());

Trait Implementations

impl<S> Clone for Document<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Document<S>

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

Formats the value using the given formatter.

impl Default for Document<Draft>

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Document<Draft>

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

Deserialize this value from the given Serde deserializer.

impl<S> Display for Document<S>

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

Formats the value using the given formatter.

impl<S> JsonSchema for Document<S>

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

The name of the generated JSON Schema.

fn json_schema(gen: &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.

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

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

impl<S> PartialEq for Document<S>

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

fn serialize<Ser: Serializer>( &self, serializer: Ser, ) -> Result<Ser::Ok, Ser::Error>

Serialize this value into the given Serde serializer.

impl<S> Eq for Document<S>