Struct Model 

pub struct Model { /* private fields */ }

A model used to generate images.

Implementations

impl Model

pub fn parts(&self) -> &[ModelPart]

Returns the parts of the model.

Examples

use svggen::{Model, ModelPart};
 
let model = Model::from(vec![
    ModelPart::from("Hello ".as_bytes()),
    ModelPart::Argument(0),
    ModelPart::from("!".as_bytes()),
]);
 
assert_eq!(model.parts(), &[
    ModelPart::Text(b"Hello ".to_vec().into()),
    ModelPart::Argument(0),
    ModelPart::Text(b"!".to_vec().into()),
]);

pub fn write<W: Write>( &self, writer: &mut W, args: &[Argument<'_>], ) -> Result<()>

Write the model to a writer.

Arguments

• writer - The writer to write the model to.
• args - The arguments to use.

Examples

use rutil::read::Readable;
use svggen::{Model, ModelPart, Image, Argument};
 
let model = Model::from(vec![
    ModelPart::from("Hello ".as_bytes()),
    ModelPart::Argument(0),
    ModelPart::from("!".as_bytes()),
]);
 
let image = Image::from("World".as_bytes());
let args = [Argument::Image(&image)];
 
let mut buffer: Vec<u8> = Vec::new();
 
// buffer implements `io::Write` so we can use it as a writer
model.write(&mut buffer, &args).unwrap();
 
assert_eq!(buffer, b"Hello World!");

pub fn generate(&self, args: &[Argument<'_>]) -> Result<Image, usize>

Creates an image from the model.

Arguments

• args - The arguments to use.

Examples

use rutil::read::Readable;
use svggen::{Model, ModelPart, Image, Argument};
 
let model = Model::from(vec![
    ModelPart::from("Hello ".as_bytes()),
    ModelPart::Argument(0),
    ModelPart::from("!".as_bytes()),
]);
 
let image = Image::from("World".as_bytes());
let args = [Argument::Image(&image)];
 
let image = model.generate(&args).unwrap();
 
assert_eq!(image.content(), b"Hello World!");

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<T: Into<Box<[ModelPart]>>> From<T> for Model

fn from(parts: T) -> Self

Creates a new model from the given parts.

Arguments

• parts - The parts of the model.

Examples

use svggen::{Model, ModelPart};
 
let model = Model::from(vec![
    ModelPart::from("Hello ".as_bytes()),
    ModelPart::Argument(0),
    ModelPart::from("!".as_bytes()),
]);
 
assert_eq!(model.parts(), &[
    ModelPart::Text(b"Hello ".to_vec().into()),
    ModelPart::Argument(0),
    ModelPart::Text(b"!".to_vec().into()),
]);

impl PartialEq for Model

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

type ParseError = ()

There is no parsing error.

fn load<R: Read>(reader: &mut R) -> Result<Self, ReadError<Self::ParseError>>

Creates a new model from a reader.

Arguments

• reader - The reader to read the model from.

Examples

use rutil::read::Readable;
use svggen::{Model, ModelPart, Image, Argument};
 
let mut data = "<svg>\n#GET 0\n</svg>".as_bytes();
 
// data implements `io::Read` so we can use it as a reader
let model = Model::load(&mut data).unwrap();
 
assert_eq!(model.parts(), &[
    ModelPart::Text(b"<svg>\n".to_vec().into()),
    ModelPart::Argument(0),
    ModelPart::Text(b"\n</svg>".to_vec().into()),
]);

fn load_file<P>(path: P) -> Result<Self, ReadError<Self::ParseError>>

where P: AsRef<Path>,

Create a new object from a file.

fn load_all<P>(path: P) -> HashMap<String, Self>

where P: AsRef<Path>,

Get all objects from a directory (one object per file).

impl Eq for Model

impl StructuralPartialEq for Model