gerber_types

Struct GenerationSoftware

Source 
pub struct GenerationSoftware {
    pub vendor: String,
    pub application: String,
    pub version: Option<String>,
}

Fields§

§vendor: String§application: String§version: Option<String>

Implementations§

Source§

impl GenerationSoftware

Source

pub fn new<S: Into<String>>( vendor: S, application: S, version: Option<S>, ) -> Self

Examples found in repository?
examples/two-boxes.rs (lines 23-27)
14fn main() {
15    let cf = CoordinateFormat::new(2, 6);
16    let commands: Vec<Command> = vec![
17        FunctionCode::GCode(GCode::Comment(CommentContent::String(
18            "Ucamco ex. 1: Two square boxes".to_string(),
19        )))
20        .into(),
21        ExtendedCode::Unit(Unit::Millimeters).into(),
22        ExtendedCode::CoordinateFormat(cf).into(),
23        ExtendedCode::FileAttribute(FileAttribute::GenerationSoftware(GenerationSoftware::new(
24            "MakerPnP",
25            "gerber-types",
26            Some(VERSION),
27        )))
28        .into(),
29        ExtendedCode::FileAttribute(FileAttribute::Part(Part::Other("example".to_string()))).into(),
30        ExtendedCode::LoadPolarity(Polarity::Dark).into(),
31        ExtendedCode::ApertureDefinition(ApertureDefinition {
32            code: 10,
33            aperture: Aperture::Circle(Circle {
34                diameter: 0.01,
35                hole_diameter: None,
36            }),
37        })
38        .into(),
39        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
40        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
41            0, 0, cf,
42        )))))
43        .into(),
44        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
45        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
46            Some(Coordinates::new(5, 0, cf)),
47            None,
48        )))
49        .into(),
50        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
51            Some(Coordinates::at_y(5, cf)),
52            None,
53        )))
54        .into(),
55        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
56            Some(Coordinates::at_x(0, cf)),
57            None,
58        )))
59        .into(),
60        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
61            Some(Coordinates::at_y(0, cf)),
62            None,
63        )))
64        .into(),
65        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::at_x(
66            6, cf,
67        )))))
68        .into(),
69        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
70            Some(Coordinates::at_x(11, cf)),
71            None,
72        )))
73        .into(),
74        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
75            Some(Coordinates::at_y(5, cf)),
76            None,
77        )))
78        .into(),
79        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
80            Some(Coordinates::at_x(6, cf)),
81            None,
82        )))
83        .into(),
84        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
85            Some(Coordinates::at_y(0, cf)),
86            None,
87        )))
88        .into(),
89        FunctionCode::MCode(MCode::EndOfFile).into(),
90    ];
91    let mut stdout = stdout();
92    commands.serialize(&mut stdout).unwrap();
93}
More examples
Hide additional examples
examples/polarities-apertures.rs (lines 20-24)
11fn main() {
12    let cf = CoordinateFormat::new(2, 6);
13    let commands: Vec<Command> = vec![
14        FunctionCode::GCode(GCode::Comment(CommentContent::String(
15            "Ucamco ex. 2: Shapes".to_string(),
16        )))
17        .into(),
18        ExtendedCode::CoordinateFormat(cf).into(),
19        ExtendedCode::Unit(Unit::Inches).into(),
20        ExtendedCode::FileAttribute(FileAttribute::GenerationSoftware(GenerationSoftware::new(
21            "Rust Gerber",
22            "gerber-types",
23            Some(VERSION),
24        )))
25        .into(),
26        ExtendedCode::FileAttribute(FileAttribute::Part(Part::Other(
27            "Only an example".to_string(),
28        )))
29        .into(),
30        ExtendedCode::LoadPolarity(Polarity::Dark).into(),
31        FunctionCode::GCode(GCode::Comment(CommentContent::String(
32            "Define Apertures".to_string(),
33        )))
34        .into(),
35        ExtendedCode::ApertureMacro(ApertureMacro::new("TARGET125").add_content(MoirePrimitive {
36            center: (0.0.into(), 0.0.into()),
37            diameter: 0.125.into(),
38            ring_thickness: 0.01.into(),
39            gap: 0.01.into(),
40            max_rings: 3,
41            cross_hair_thickness: 0.003.into(),
42            cross_hair_length: 0.150.into(),
43            angle: 0.0.into(),
44        }))
45        .into(),
46        ExtendedCode::ApertureMacro(ApertureMacro::new("THERMAL80").add_content(
47            ThermalPrimitive {
48                center: (0.0.into(), 0.0.into()),
49                outer_diameter: 0.08.into(),
50                inner_diameter: 0.055.into(),
51                gap: 0.0125.into(),
52                angle: 45.0.into(),
53            },
54        ))
55        .into(),
56        ExtendedCode::ApertureDefinition(ApertureDefinition {
57            code: 10,
58            aperture: Aperture::Circle(Circle {
59                diameter: 0.01,
60                hole_diameter: None,
61            }),
62        })
63        .into(),
64        ExtendedCode::ApertureDefinition(ApertureDefinition {
65            code: 11,
66            aperture: Aperture::Circle(Circle {
67                diameter: 0.06,
68                hole_diameter: None,
69            }),
70        })
71        .into(),
72        ExtendedCode::ApertureDefinition(ApertureDefinition {
73            code: 12,
74            aperture: Aperture::Rectangle(Rectangular {
75                x: 0.06,
76                y: 0.06,
77                hole_diameter: None,
78            }),
79        })
80        .into(),
81        ExtendedCode::ApertureDefinition(ApertureDefinition {
82            code: 13,
83            aperture: Aperture::Rectangle(Rectangular {
84                x: 0.04,
85                y: 0.1,
86                hole_diameter: None,
87            }),
88        })
89        .into(),
90        ExtendedCode::ApertureDefinition(ApertureDefinition {
91            code: 14,
92            aperture: Aperture::Rectangle(Rectangular {
93                x: 0.1,
94                y: 0.04,
95                hole_diameter: None,
96            }),
97        })
98        .into(),
99        ExtendedCode::ApertureDefinition(ApertureDefinition {
100            code: 15,
101            aperture: Aperture::Obround(Rectangular {
102                x: 0.04,
103                y: 0.1,
104                hole_diameter: None,
105            }),
106        })
107        .into(),
108        ExtendedCode::ApertureDefinition(ApertureDefinition {
109            code: 16,
110            aperture: Aperture::Polygon(Polygon {
111                diameter: 0.1,
112                vertices: 3,
113                rotation: None,
114                hole_diameter: None,
115            }),
116        })
117        .into(),
118        ExtendedCode::ApertureDefinition(ApertureDefinition {
119            code: 18,
120            aperture: Aperture::Macro("TARGET125".to_string(), None),
121        })
122        .into(),
123        ExtendedCode::ApertureDefinition(ApertureDefinition {
124            code: 19,
125            aperture: Aperture::Macro("THERMAL80".to_string(), None),
126        })
127        .into(),
128        FunctionCode::GCode(GCode::Comment(CommentContent::String(
129            "Start image generation".to_string(),
130        )))
131        .into(),
132        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
133        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
134            0,
135            CoordinateNumber::try_from(0.25).unwrap(),
136            cf,
137        )))))
138        .into(),
139        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
140        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
141            Some(Coordinates::new(0, 0, cf)),
142            None,
143        )))
144        .into(),
145        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
146            Some(Coordinates::new(
147                CoordinateNumber::try_from(0.25).unwrap(),
148                0,
149                cf,
150            )),
151            None,
152        )))
153        .into(),
154        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
155            1, 1, cf,
156        )))))
157        .into(),
158        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
159            Some(Coordinates::at_x(
160                CoordinateNumber::try_from(1.5).unwrap(),
161                cf,
162            )),
163            None,
164        )))
165        .into(),
166        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
167            Some(Coordinates::new(
168                2,
169                CoordinateNumber::try_from(1.5).unwrap(),
170                cf,
171            )),
172            None,
173        )))
174        .into(),
175        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::at_x(
176            CoordinateNumber::try_from(2.5).unwrap(),
177            cf,
178        )))))
179        .into(),
180        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
181            Some(Coordinates::at_y(1, cf)),
182            None,
183        )))
184        .into(),
185        FunctionCode::DCode(DCode::SelectAperture(11)).into(),
186        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
187            1, 1, cf,
188        )))))
189        .into(),
190        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
191            2, 1, cf,
192        )))))
193        .into(),
194        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
195            CoordinateNumber::try_from(2.5).unwrap(),
196            1,
197            cf,
198        )))))
199        .into(),
200        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
201            CoordinateNumber::try_from(2.5).unwrap(),
202            CoordinateNumber::try_from(1.5).unwrap(),
203            cf,
204        )))))
205        .into(),
206        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
207            2,
208            CoordinateNumber::try_from(1.5).unwrap(),
209            cf,
210        )))))
211        .into(),
212        FunctionCode::DCode(DCode::SelectAperture(12)).into(),
213        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
214            1,
215            CoordinateNumber::try_from(1.5).unwrap(),
216            cf,
217        )))))
218        .into(),
219        FunctionCode::DCode(DCode::SelectAperture(13)).into(),
220        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
221            3,
222            CoordinateNumber::try_from(1.5).unwrap(),
223            cf,
224        )))))
225        .into(),
226        FunctionCode::DCode(DCode::SelectAperture(14)).into(),
227        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
228            3,
229            CoordinateNumber::try_from(1.25).unwrap(),
230            cf,
231        )))))
232        .into(),
233        FunctionCode::DCode(DCode::SelectAperture(15)).into(),
234        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
235            3, 1, cf,
236        )))))
237        .into(),
238        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
239        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
240            CoordinateNumber::try_from(3.75).unwrap(),
241            1,
242            cf,
243        )))))
244        .into(),
245        FunctionCode::GCode(GCode::QuadrantMode(QuadrantMode::Multi)).into(),
246        FunctionCode::GCode(GCode::InterpolationMode(
247            InterpolationMode::CounterclockwiseCircular,
248        ))
249        .into(),
250        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
251            Some(Coordinates::new(
252                CoordinateNumber::try_from(3.75).unwrap(),
253                1,
254                cf,
255            )),
256            Some(CoordinateOffset::new(
257                CoordinateNumber::try_from(0.25).unwrap(),
258                0,
259                cf,
260            )),
261        )))
262        .into(),
263        FunctionCode::DCode(DCode::SelectAperture(16)).into(),
264        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
265            CoordinateNumber::try_from(3.4).unwrap(),
266            1,
267            cf,
268        )))))
269        .into(),
270        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
271            CoordinateNumber::try_from(3.5).unwrap(),
272            CoordinateNumber::try_from(0.9).unwrap(),
273            cf,
274        )))))
275        .into(),
276        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
277        FunctionCode::GCode(GCode::RegionMode(true)).into(),
278        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
279            CoordinateNumber::try_from(0.5).unwrap(),
280            2,
281            cf,
282        )))))
283        .into(),
284        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
285        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
286            Some(Coordinates::at_y(
287                CoordinateNumber::try_from(3.75).unwrap(),
288                cf,
289            )),
290            None,
291        )))
292        .into(),
293        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
294            Some(Coordinates::at_x(
295                CoordinateNumber::try_from(3.75).unwrap(),
296                cf,
297            )),
298            None,
299        )))
300        .into(),
301        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
302            Some(Coordinates::at_y(2, cf)),
303            None,
304        )))
305        .into(),
306        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
307            Some(Coordinates::at_x(
308                CoordinateNumber::try_from(0.5).unwrap(),
309                cf,
310            )),
311            None,
312        )))
313        .into(),
314        FunctionCode::GCode(GCode::RegionMode(false)).into(),
315        FunctionCode::DCode(DCode::SelectAperture(18)).into(),
316        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
317            0,
318            CoordinateNumber::try_from(3.875).unwrap(),
319            cf,
320        )))))
321        .into(),
322        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
323            CoordinateNumber::try_from(3.875).unwrap(),
324            CoordinateNumber::try_from(3.875).unwrap(),
325            cf,
326        )))))
327        .into(),
328        ExtendedCode::LoadPolarity(Polarity::Clear).into(),
329        FunctionCode::GCode(GCode::RegionMode(true)).into(),
330        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
331            1,
332            CoordinateNumber::try_from(2.5).unwrap(),
333            cf,
334        )))))
335        .into(),
336        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
337            Some(Coordinates::at_y(3, cf)),
338            None,
339        )))
340        .into(),
341        FunctionCode::GCode(GCode::QuadrantMode(QuadrantMode::Single)).into(),
342        FunctionCode::GCode(GCode::InterpolationMode(
343            InterpolationMode::ClockwiseCircular,
344        ))
345        .into(),
346        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
347            Some(Coordinates::new(
348                CoordinateNumber::try_from(1.25).unwrap(),
349                CoordinateNumber::try_from(3.25).unwrap(),
350                cf,
351            )),
352            Some(CoordinateOffset::new(
353                CoordinateNumber::try_from(0.25).unwrap(),
354                0,
355                cf,
356            )),
357        )))
358        .into(),
359        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
360        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
361            Some(Coordinates::at_x(3, cf)),
362            None,
363        )))
364        .into(),
365        FunctionCode::GCode(GCode::QuadrantMode(QuadrantMode::Multi)).into(),
366        FunctionCode::GCode(GCode::InterpolationMode(
367            InterpolationMode::ClockwiseCircular,
368        ))
369        .into(),
370        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
371            Some(Coordinates::new(
372                3,
373                CoordinateNumber::try_from(2.5).unwrap(),
374                cf,
375            )),
376            Some(CoordinateOffset::new(
377                0,
378                CoordinateNumber::try_from(0.375).unwrap(),
379                cf,
380            )),
381        )))
382        .into(),
383        FunctionCode::GCode(GCode::InterpolationMode(InterpolationMode::Linear)).into(),
384        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
385            Some(Coordinates::at_x(1, cf)),
386            None,
387        )))
388        .into(),
389        FunctionCode::GCode(GCode::RegionMode(false)).into(),
390        ExtendedCode::LoadPolarity(Polarity::Dark).into(),
391        FunctionCode::DCode(DCode::SelectAperture(10)).into(),
392        FunctionCode::DCode(DCode::Operation(Operation::Move(Some(Coordinates::new(
393            CoordinateNumber::try_from(1.5).unwrap(),
394            CoordinateNumber::try_from(2.875).unwrap(),
395            cf,
396        )))))
397        .into(),
398        FunctionCode::DCode(DCode::Operation(Operation::Interpolate(
399            Some(Coordinates::at_x(2, cf)),
400            None,
401        )))
402        .into(),
403        FunctionCode::DCode(DCode::SelectAperture(11)).into(),
404        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
405            CoordinateNumber::try_from(1.5).unwrap(),
406            CoordinateNumber::try_from(2.875).unwrap(),
407            cf,
408        )))))
409        .into(),
410        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::at_x(
411            2, cf,
412        )))))
413        .into(),
414        FunctionCode::DCode(DCode::SelectAperture(19)).into(),
415        FunctionCode::DCode(DCode::Operation(Operation::Flash(Some(Coordinates::new(
416            CoordinateNumber::try_from(2.875).unwrap(),
417            CoordinateNumber::try_from(2.875).unwrap(),
418            cf,
419        )))))
420        .into(),
421        ExtendedCode::FileAttribute(FileAttribute::Md5(
422            "6ab9e892830469cdff7e3e346331d404".to_string(),
423        ))
424        .into(),
425        FunctionCode::MCode(MCode::EndOfFile).into(),
426    ];
427    let mut stdout = stdout();
428    commands.serialize(&mut stdout).unwrap();
429}

Trait Implementations§

Source§

impl Clone for GenerationSoftware

Source§

fn clone(&self) -> GenerationSoftware

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for GenerationSoftware

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Hash for GenerationSoftware

Source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
Source§

impl PartialEq for GenerationSoftware

Source§

fn eq(&self, other: &GenerationSoftware) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
Source§

impl Eq for GenerationSoftware

Source§

impl StructuralPartialEq for GenerationSoftware

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.