Struct Model 

pub struct Model {
    pub unit: String,
    pub xmlns: String,
    pub required_extensions: Vec<Extension>,
    pub required_custom_extensions: Vec<String>,
    pub metadata: Vec<MetadataEntry>,
    pub thumbnail: Option<Thumbnail>,
    pub resources: Resources,
    pub build: Build,
    pub secure_content: Option<SecureContentInfo>,
}

Complete 3MF model

Fields

unit: String

Unit of measurement (e.g., “millimeter”, “inch”)

xmlns: String

XML namespace

required_extensions: Vec<Extension>

Required extensions for this model Extensions that the consumer must support to properly process this file

required_custom_extensions: Vec<String>

Required custom extension namespaces (not part of standard 3MF)

metadata: Vec<MetadataEntry>

Metadata entries with name, value, and optional preservation flag

thumbnail: Option<Thumbnail>

Thumbnail metadata (if present in the package)

resources: Resources

Resources (objects, materials)

build: Build

Build specification

secure_content: Option<SecureContentInfo>

Secure content information (if secure content extension is used)

Implementations

impl Model

pub fn new() -> Self

Create a new empty model

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

Get metadata value by name (helper for backward compatibility)

pub fn has_metadata(&self, name: &str) -> bool

Check if metadata entry exists with the given name

impl Model

pub fn from_reader<R: Read + Seek>(reader: R) -> Result<Self>

Parse a 3MF file from a reader

This method uses the default parser configuration which supports all known extensions. For backward compatibility, this will accept files with any required extensions.

Arguments

• reader - A reader containing the 3MF file data

Example

use lib3mf::Model;
use std::fs::File;

let file = File::open("model.3mf")?;
let model = Model::from_reader(file)?;

pub fn from_reader_with_config<R: Read + Seek>( reader: R, config: ParserConfig, ) -> Result<Self>

Parse a 3MF file from a reader with custom configuration

This method allows you to specify which extensions you support. If the file requires an extension you don’t support, an error will be returned.

Arguments

• reader - A reader containing the 3MF file data
• config - Parser configuration specifying supported extensions

Example

use lib3mf::{Model, ParserConfig, Extension};
use std::fs::File;

let file = File::open("model.3mf")?;

// Only support core and material extensions
let config = ParserConfig::new()
    .with_extension(Extension::Material);

let model = Model::from_reader_with_config(file, config)?;

pub fn read_thumbnail<R: Read + Seek>(reader: R) -> Result<Option<Vec<u8>>>

Read thumbnail binary data from a 3MF file

Returns the thumbnail image data as a byte vector if a thumbnail is present. Returns None if no thumbnail is found.

This is a convenience method that reads the thumbnail from a separate reader. The model metadata must have already been parsed to know if a thumbnail exists.

Arguments

• reader - A reader containing the 3MF file data

Example

use lib3mf::Model;
use std::fs::File;

let file = File::open("model.3mf")?;
if let Some(thumbnail_data) = Model::read_thumbnail(file)? {
    println!("Thumbnail size: {} bytes", thumbnail_data.len());
    std::fs::write("thumbnail.png", thumbnail_data)?;
}

pub fn to_writer<W: Write + Seek>(self, writer: W) -> Result<W>

Write a 3MF file to a writer

This method serializes the Model to a complete 3MF file (ZIP archive) and writes it to the provided writer.

Arguments

• writer - A writer to write the 3MF file data to

Example

use lib3mf::Model;
use std::fs::File;

let mut model = Model::new();
// ... populate model with data ...

let file = File::create("output.3mf")?;
model.to_writer(file)?;

pub fn to_writer_with_registry<W: Write + Seek>( self, writer: W, registry: &ExtensionRegistry, ) -> Result<W>

Write a 3MF file to a writer with extension registry

This method serializes the Model to a complete 3MF file (ZIP archive) and writes it to the provided writer. Before serialization, it calls pre_write() on all registered extension handlers, allowing extensions to prepare or transform data before writing.

Arguments

• writer - A writer to write the 3MF file data to
• registry - Extension registry containing handlers that will be called before writing

Example

use lib3mf::{Model, create_default_registry};
use std::fs::File;

let mut model = Model::new();
// ... populate model with data ...

// Create registry with all standard extension handlers
let registry = create_default_registry();

let file = File::create("output.3mf")?;
model.to_writer_with_registry(file, &registry)?;

pub fn write_to_file<P: AsRef<Path>>(self, path: P) -> Result<()>

Write a 3MF file to a file path

This is a convenience method that creates a file and writes the 3MF data to it. The file is automatically flushed and closed when the method completes.

Arguments

• path - Path to the output file

Example

use lib3mf::Model;

let mut model = Model::new();
// ... populate model with data ...

model.write_to_file("output.3mf")?;

pub fn write_to_file_with_registry<P: AsRef<Path>>( self, path: P, registry: &ExtensionRegistry, ) -> Result<()>

Write a 3MF file to a file path with extension registry

This is a convenience method that creates a file and writes the 3MF data to it. Before writing, it calls pre_write() on all registered extension handlers. The file is automatically flushed and closed when the method completes.

Arguments

• path - Path to the output file
• registry - Extension registry containing handlers that will be called before writing

Example

use lib3mf::{Model, create_default_registry};

let mut model = Model::new();
// ... populate model with data ...

// Create registry with all standard extension handlers
let registry = create_default_registry();

model.write_to_file_with_registry("output.3mf", &registry)?;

Trait Implementations

impl Clone for Model

fn clone(&self) -> Model

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Model

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

Formats the value using the given formatter.

impl Default for Model

fn default() -> Self

Returns the “default value” for a type.