Viewport

tinybit

Struct Viewport 

Source 
pub struct Viewport {
    pub position: ScreenPos,
    pub size: ScreenSize,
    /* private fields */
}
Expand description

Represents a drawable area on screen.

Fields§

§position: ScreenPos

The viewport’s position on screen. Where 0,0 is the top left corner

§size: ScreenSize

The size of the viewport. Should probably match the size of the camera that is used with this viewport.

Implementations§

Source§

impl Viewport

Source

pub fn new(position: ScreenPos, size: ScreenSize) -> Self

Create a new viewport with a given screen position.

Examples found in repository?
examples/simple.rs (line 12)
7fn main() {
8    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
9
10    // Viewport
11    let viewport_size = ScreenSize::new(width / 2, height / 2);
12    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
13
14    // Camera
15    let (width, height) = (width as i64, height as i64);
16    let camera_size = WorldSize::new(width / 2, height / 2);
17    let camera_pos = WorldPos::new(width, height);
18    let camera = Camera::new(camera_pos, camera_size);
19
20    // Renderer
21    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
22    let mut renderer = Renderer::new(stdout_renderer);
23
24    // Player
25    let mut player = ('@', camera_pos);
26
27    let (_, events) = events::<()>(EventModel::Fps(20));
28    for event in events {
29        match event {
30            Event::User(()) => {}
31            Event::Tick => {
32                let pixel = Pixel::new(player.0, camera.to_screen(player.1), None, None);
33                viewport.draw_pixel(pixel);
34                let _ = renderer.render(&mut viewport);
35                viewport.swap_buffers();
36            }
37            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
38            Event::Key(KeyEvent { code: kc, .. }) => {
39                match kc {
40                    KeyCode::Left => { player.1.x -= 1; }
41                    KeyCode::Right => { player.1.x += 1; }
42                    KeyCode::Up => { player.1.y -= 1; }
43                    KeyCode::Down => { player.1.y += 1; }
44                    _ => {}
45                }
46            }
47            Event::Resize(_w, _h) => {}
48        }
49    }
50}
More examples
Hide additional examples
examples/world.rs (line 29)
24fn main() {
25    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
26
27    // Viewport
28    let viewport_size = ScreenSize::new(width / 2, height / 2);
29    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
30    let mut status_viewport = Viewport::new(ScreenPos::zero(), ScreenSize::new(width, 3));
31
32    // Camera
33    let camera_pos = WorldPos::zero();
34    let mut camera = Camera::from_viewport(camera_pos, &viewport).with_limit(5, 5, 5, 5);
35
36    // Renderer
37    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
38    let mut renderer = Renderer::new(stdout_renderer);
39
40    // Player
41    let mut player = ('@', camera_pos);
42    let mut player_pixel = Pixel::new(player.0, camera.to_screen(player.1), Some(Color::Yellow), None);
43
44    // Mob
45    let mut mob = Mob {
46        pixel: Pixel::new('&', camera.to_screen(player.1), Some(Color::Red), None),
47        world_pos: WorldPos::new(camera_pos.x - 2, camera_pos.y - 6),
48        tick: 0,
49    };
50
51    // "Grass"
52    let grass_positions = field_of_grass(&camera);
53    let mut grass = grass_positions.iter().map(|_| Pixel::new(
54        'w',
55        camera.to_screen(camera.position),
56        Some(Color::Green),
57        None
58    )).collect::<Vec<_>>();
59
60    let (_, events) = events::<()>(EventModel::Fps(20));
61    for event in events {
62        match event {
63            Event::User(()) => {}
64            Event::Tick => {
65                viewport.draw_pixels(&grass);
66                viewport.draw_pixel(player_pixel);
67                mob.pixel.pos = camera.to_screen(mob.world_pos);
68                viewport.draw_pixel(mob.pixel);
69
70                // Move the mob to the right
71                mob.update();
72                let camera_border = Border::thin(Some(Color::Green), None);
73                viewport.draw_widget(&camera_border, ScreenPos::zero());
74
75                // Track the player
76                camera.track(player.1);
77                player_pixel.pos = camera.to_screen(player.1);
78                grass_positions.iter().zip(&mut grass).for_each(|(world_pos, grass)| {
79                    grass.pos = camera.to_screen(*world_pos);
80                });
81
82                // Status
83                let status = Text::new(
84                    format!("player x {} | y {}  camera x {} | y {}",
85                        player.1.x,
86                        player.1.y, 
87                        camera.position.x,
88                        camera.position.y,
89                    ),
90                    Some(Color::Red),
91                    None,
92                );
93
94                // Status border
95                let status_border = Border::new("╭─╮│╯─╰│", Some(Color::White), None);
96
97                status_viewport.swap_buffers();
98                status_viewport.draw_widget(&status_border, ScreenPos::zero());
99                status_viewport.draw_widget(&status, ScreenPos::new(1, 1));
100                let _ = renderer.render(&mut status_viewport);
101
102                // Render and swap the buffers so there is no 
103                // residual characters
104                let _ = renderer.render(&mut viewport);
105                viewport.swap_buffers();
106            }
107            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
108            Event::Key(KeyEvent { code: kc, .. }) => {
109                match kc {
110                    KeyCode::Left => { player.1.x -= 1; }
111                    KeyCode::Right => { player.1.x += 1; }
112                    KeyCode::Up => { player.1.y -= 1; }
113                    KeyCode::Down => { player.1.y += 1; }
114                    _ => {}
115                }
116            }
117            Event::Resize(_w, _h) => {}
118        }
119    }
120}
Source

pub fn resize(&mut self, width: u16, height: u16)

Resize the viewport. Remember to clear the renderer or residual characters might remain.

Source

pub fn draw_pixels(&mut self, pixels: &[Pixel])

Draw the pixels onto the renderable surface layers. This is offset by the camera and the viewport.

Examples found in repository?
examples/world.rs (line 65)
24fn main() {
25    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
26
27    // Viewport
28    let viewport_size = ScreenSize::new(width / 2, height / 2);
29    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
30    let mut status_viewport = Viewport::new(ScreenPos::zero(), ScreenSize::new(width, 3));
31
32    // Camera
33    let camera_pos = WorldPos::zero();
34    let mut camera = Camera::from_viewport(camera_pos, &viewport).with_limit(5, 5, 5, 5);
35
36    // Renderer
37    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
38    let mut renderer = Renderer::new(stdout_renderer);
39
40    // Player
41    let mut player = ('@', camera_pos);
42    let mut player_pixel = Pixel::new(player.0, camera.to_screen(player.1), Some(Color::Yellow), None);
43
44    // Mob
45    let mut mob = Mob {
46        pixel: Pixel::new('&', camera.to_screen(player.1), Some(Color::Red), None),
47        world_pos: WorldPos::new(camera_pos.x - 2, camera_pos.y - 6),
48        tick: 0,
49    };
50
51    // "Grass"
52    let grass_positions = field_of_grass(&camera);
53    let mut grass = grass_positions.iter().map(|_| Pixel::new(
54        'w',
55        camera.to_screen(camera.position),
56        Some(Color::Green),
57        None
58    )).collect::<Vec<_>>();
59
60    let (_, events) = events::<()>(EventModel::Fps(20));
61    for event in events {
62        match event {
63            Event::User(()) => {}
64            Event::Tick => {
65                viewport.draw_pixels(&grass);
66                viewport.draw_pixel(player_pixel);
67                mob.pixel.pos = camera.to_screen(mob.world_pos);
68                viewport.draw_pixel(mob.pixel);
69
70                // Move the mob to the right
71                mob.update();
72                let camera_border = Border::thin(Some(Color::Green), None);
73                viewport.draw_widget(&camera_border, ScreenPos::zero());
74
75                // Track the player
76                camera.track(player.1);
77                player_pixel.pos = camera.to_screen(player.1);
78                grass_positions.iter().zip(&mut grass).for_each(|(world_pos, grass)| {
79                    grass.pos = camera.to_screen(*world_pos);
80                });
81
82                // Status
83                let status = Text::new(
84                    format!("player x {} | y {}  camera x {} | y {}",
85                        player.1.x,
86                        player.1.y, 
87                        camera.position.x,
88                        camera.position.y,
89                    ),
90                    Some(Color::Red),
91                    None,
92                );
93
94                // Status border
95                let status_border = Border::new("╭─╮│╯─╰│", Some(Color::White), None);
96
97                status_viewport.swap_buffers();
98                status_viewport.draw_widget(&status_border, ScreenPos::zero());
99                status_viewport.draw_widget(&status, ScreenPos::new(1, 1));
100                let _ = renderer.render(&mut status_viewport);
101
102                // Render and swap the buffers so there is no 
103                // residual characters
104                let _ = renderer.render(&mut viewport);
105                viewport.swap_buffers();
106            }
107            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
108            Event::Key(KeyEvent { code: kc, .. }) => {
109                match kc {
110                    KeyCode::Left => { player.1.x -= 1; }
111                    KeyCode::Right => { player.1.x += 1; }
112                    KeyCode::Up => { player.1.y -= 1; }
113                    KeyCode::Down => { player.1.y += 1; }
114                    _ => {}
115                }
116            }
117            Event::Resize(_w, _h) => {}
118        }
119    }
120}
Source

pub fn draw_pixel(&mut self, pixel: Pixel)

Draw a single pixel onto the rendereable surface layers. This is called from draw_pixels for each pixel.

This is useful if it’s desired to draw just one pixel.

Examples found in repository?
examples/simple.rs (line 33)
7fn main() {
8    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
9
10    // Viewport
11    let viewport_size = ScreenSize::new(width / 2, height / 2);
12    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
13
14    // Camera
15    let (width, height) = (width as i64, height as i64);
16    let camera_size = WorldSize::new(width / 2, height / 2);
17    let camera_pos = WorldPos::new(width, height);
18    let camera = Camera::new(camera_pos, camera_size);
19
20    // Renderer
21    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
22    let mut renderer = Renderer::new(stdout_renderer);
23
24    // Player
25    let mut player = ('@', camera_pos);
26
27    let (_, events) = events::<()>(EventModel::Fps(20));
28    for event in events {
29        match event {
30            Event::User(()) => {}
31            Event::Tick => {
32                let pixel = Pixel::new(player.0, camera.to_screen(player.1), None, None);
33                viewport.draw_pixel(pixel);
34                let _ = renderer.render(&mut viewport);
35                viewport.swap_buffers();
36            }
37            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
38            Event::Key(KeyEvent { code: kc, .. }) => {
39                match kc {
40                    KeyCode::Left => { player.1.x -= 1; }
41                    KeyCode::Right => { player.1.x += 1; }
42                    KeyCode::Up => { player.1.y -= 1; }
43                    KeyCode::Down => { player.1.y += 1; }
44                    _ => {}
45                }
46            }
47            Event::Resize(_w, _h) => {}
48        }
49    }
50}
More examples
Hide additional examples
examples/world.rs (line 66)
24fn main() {
25    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
26
27    // Viewport
28    let viewport_size = ScreenSize::new(width / 2, height / 2);
29    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
30    let mut status_viewport = Viewport::new(ScreenPos::zero(), ScreenSize::new(width, 3));
31
32    // Camera
33    let camera_pos = WorldPos::zero();
34    let mut camera = Camera::from_viewport(camera_pos, &viewport).with_limit(5, 5, 5, 5);
35
36    // Renderer
37    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
38    let mut renderer = Renderer::new(stdout_renderer);
39
40    // Player
41    let mut player = ('@', camera_pos);
42    let mut player_pixel = Pixel::new(player.0, camera.to_screen(player.1), Some(Color::Yellow), None);
43
44    // Mob
45    let mut mob = Mob {
46        pixel: Pixel::new('&', camera.to_screen(player.1), Some(Color::Red), None),
47        world_pos: WorldPos::new(camera_pos.x - 2, camera_pos.y - 6),
48        tick: 0,
49    };
50
51    // "Grass"
52    let grass_positions = field_of_grass(&camera);
53    let mut grass = grass_positions.iter().map(|_| Pixel::new(
54        'w',
55        camera.to_screen(camera.position),
56        Some(Color::Green),
57        None
58    )).collect::<Vec<_>>();
59
60    let (_, events) = events::<()>(EventModel::Fps(20));
61    for event in events {
62        match event {
63            Event::User(()) => {}
64            Event::Tick => {
65                viewport.draw_pixels(&grass);
66                viewport.draw_pixel(player_pixel);
67                mob.pixel.pos = camera.to_screen(mob.world_pos);
68                viewport.draw_pixel(mob.pixel);
69
70                // Move the mob to the right
71                mob.update();
72                let camera_border = Border::thin(Some(Color::Green), None);
73                viewport.draw_widget(&camera_border, ScreenPos::zero());
74
75                // Track the player
76                camera.track(player.1);
77                player_pixel.pos = camera.to_screen(player.1);
78                grass_positions.iter().zip(&mut grass).for_each(|(world_pos, grass)| {
79                    grass.pos = camera.to_screen(*world_pos);
80                });
81
82                // Status
83                let status = Text::new(
84                    format!("player x {} | y {}  camera x {} | y {}",
85                        player.1.x,
86                        player.1.y, 
87                        camera.position.x,
88                        camera.position.y,
89                    ),
90                    Some(Color::Red),
91                    None,
92                );
93
94                // Status border
95                let status_border = Border::new("╭─╮│╯─╰│", Some(Color::White), None);
96
97                status_viewport.swap_buffers();
98                status_viewport.draw_widget(&status_border, ScreenPos::zero());
99                status_viewport.draw_widget(&status, ScreenPos::new(1, 1));
100                let _ = renderer.render(&mut status_viewport);
101
102                // Render and swap the buffers so there is no 
103                // residual characters
104                let _ = renderer.render(&mut viewport);
105                viewport.swap_buffers();
106            }
107            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
108            Event::Key(KeyEvent { code: kc, .. }) => {
109                match kc {
110                    KeyCode::Left => { player.1.x -= 1; }
111                    KeyCode::Right => { player.1.x += 1; }
112                    KeyCode::Up => { player.1.y -= 1; }
113                    KeyCode::Down => { player.1.y += 1; }
114                    _ => {}
115                }
116            }
117            Event::Resize(_w, _h) => {}
118        }
119    }
120}
Source

pub fn draw_widget(&mut self, widget: &impl Widget, offset: ScreenPos)

Draw a widget with an offset in the viewport.

Examples found in repository?
examples/world.rs (line 73)
24fn main() {
25    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
26
27    // Viewport
28    let viewport_size = ScreenSize::new(width / 2, height / 2);
29    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
30    let mut status_viewport = Viewport::new(ScreenPos::zero(), ScreenSize::new(width, 3));
31
32    // Camera
33    let camera_pos = WorldPos::zero();
34    let mut camera = Camera::from_viewport(camera_pos, &viewport).with_limit(5, 5, 5, 5);
35
36    // Renderer
37    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
38    let mut renderer = Renderer::new(stdout_renderer);
39
40    // Player
41    let mut player = ('@', camera_pos);
42    let mut player_pixel = Pixel::new(player.0, camera.to_screen(player.1), Some(Color::Yellow), None);
43
44    // Mob
45    let mut mob = Mob {
46        pixel: Pixel::new('&', camera.to_screen(player.1), Some(Color::Red), None),
47        world_pos: WorldPos::new(camera_pos.x - 2, camera_pos.y - 6),
48        tick: 0,
49    };
50
51    // "Grass"
52    let grass_positions = field_of_grass(&camera);
53    let mut grass = grass_positions.iter().map(|_| Pixel::new(
54        'w',
55        camera.to_screen(camera.position),
56        Some(Color::Green),
57        None
58    )).collect::<Vec<_>>();
59
60    let (_, events) = events::<()>(EventModel::Fps(20));
61    for event in events {
62        match event {
63            Event::User(()) => {}
64            Event::Tick => {
65                viewport.draw_pixels(&grass);
66                viewport.draw_pixel(player_pixel);
67                mob.pixel.pos = camera.to_screen(mob.world_pos);
68                viewport.draw_pixel(mob.pixel);
69
70                // Move the mob to the right
71                mob.update();
72                let camera_border = Border::thin(Some(Color::Green), None);
73                viewport.draw_widget(&camera_border, ScreenPos::zero());
74
75                // Track the player
76                camera.track(player.1);
77                player_pixel.pos = camera.to_screen(player.1);
78                grass_positions.iter().zip(&mut grass).for_each(|(world_pos, grass)| {
79                    grass.pos = camera.to_screen(*world_pos);
80                });
81
82                // Status
83                let status = Text::new(
84                    format!("player x {} | y {}  camera x {} | y {}",
85                        player.1.x,
86                        player.1.y, 
87                        camera.position.x,
88                        camera.position.y,
89                    ),
90                    Some(Color::Red),
91                    None,
92                );
93
94                // Status border
95                let status_border = Border::new("╭─╮│╯─╰│", Some(Color::White), None);
96
97                status_viewport.swap_buffers();
98                status_viewport.draw_widget(&status_border, ScreenPos::zero());
99                status_viewport.draw_widget(&status, ScreenPos::new(1, 1));
100                let _ = renderer.render(&mut status_viewport);
101
102                // Render and swap the buffers so there is no 
103                // residual characters
104                let _ = renderer.render(&mut viewport);
105                viewport.swap_buffers();
106            }
107            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
108            Event::Key(KeyEvent { code: kc, .. }) => {
109                match kc {
110                    KeyCode::Left => { player.1.x -= 1; }
111                    KeyCode::Right => { player.1.x += 1; }
112                    KeyCode::Up => { player.1.y -= 1; }
113                    KeyCode::Down => { player.1.y += 1; }
114                    _ => {}
115                }
116            }
117            Event::Resize(_w, _h) => {}
118        }
119    }
120}
Source

pub fn swap_buffers(&mut self)

Examples found in repository?
examples/simple.rs (line 35)
7fn main() {
8    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
9
10    // Viewport
11    let viewport_size = ScreenSize::new(width / 2, height / 2);
12    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
13
14    // Camera
15    let (width, height) = (width as i64, height as i64);
16    let camera_size = WorldSize::new(width / 2, height / 2);
17    let camera_pos = WorldPos::new(width, height);
18    let camera = Camera::new(camera_pos, camera_size);
19
20    // Renderer
21    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
22    let mut renderer = Renderer::new(stdout_renderer);
23
24    // Player
25    let mut player = ('@', camera_pos);
26
27    let (_, events) = events::<()>(EventModel::Fps(20));
28    for event in events {
29        match event {
30            Event::User(()) => {}
31            Event::Tick => {
32                let pixel = Pixel::new(player.0, camera.to_screen(player.1), None, None);
33                viewport.draw_pixel(pixel);
34                let _ = renderer.render(&mut viewport);
35                viewport.swap_buffers();
36            }
37            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
38            Event::Key(KeyEvent { code: kc, .. }) => {
39                match kc {
40                    KeyCode::Left => { player.1.x -= 1; }
41                    KeyCode::Right => { player.1.x += 1; }
42                    KeyCode::Up => { player.1.y -= 1; }
43                    KeyCode::Down => { player.1.y += 1; }
44                    _ => {}
45                }
46            }
47            Event::Resize(_w, _h) => {}
48        }
49    }
50}
More examples
Hide additional examples
examples/world.rs (line 97)
24fn main() {
25    let (width, height) = term_size().expect("Can't get the term size? Can't play the game!");
26
27    // Viewport
28    let viewport_size = ScreenSize::new(width / 2, height / 2);
29    let mut viewport = Viewport::new(ScreenPos::new(0, 4), viewport_size);
30    let mut status_viewport = Viewport::new(ScreenPos::zero(), ScreenSize::new(width, 3));
31
32    // Camera
33    let camera_pos = WorldPos::zero();
34    let mut camera = Camera::from_viewport(camera_pos, &viewport).with_limit(5, 5, 5, 5);
35
36    // Renderer
37    let stdout_renderer = StdoutTarget::new().expect("Failed to enter raw mode");
38    let mut renderer = Renderer::new(stdout_renderer);
39
40    // Player
41    let mut player = ('@', camera_pos);
42    let mut player_pixel = Pixel::new(player.0, camera.to_screen(player.1), Some(Color::Yellow), None);
43
44    // Mob
45    let mut mob = Mob {
46        pixel: Pixel::new('&', camera.to_screen(player.1), Some(Color::Red), None),
47        world_pos: WorldPos::new(camera_pos.x - 2, camera_pos.y - 6),
48        tick: 0,
49    };
50
51    // "Grass"
52    let grass_positions = field_of_grass(&camera);
53    let mut grass = grass_positions.iter().map(|_| Pixel::new(
54        'w',
55        camera.to_screen(camera.position),
56        Some(Color::Green),
57        None
58    )).collect::<Vec<_>>();
59
60    let (_, events) = events::<()>(EventModel::Fps(20));
61    for event in events {
62        match event {
63            Event::User(()) => {}
64            Event::Tick => {
65                viewport.draw_pixels(&grass);
66                viewport.draw_pixel(player_pixel);
67                mob.pixel.pos = camera.to_screen(mob.world_pos);
68                viewport.draw_pixel(mob.pixel);
69
70                // Move the mob to the right
71                mob.update();
72                let camera_border = Border::thin(Some(Color::Green), None);
73                viewport.draw_widget(&camera_border, ScreenPos::zero());
74
75                // Track the player
76                camera.track(player.1);
77                player_pixel.pos = camera.to_screen(player.1);
78                grass_positions.iter().zip(&mut grass).for_each(|(world_pos, grass)| {
79                    grass.pos = camera.to_screen(*world_pos);
80                });
81
82                // Status
83                let status = Text::new(
84                    format!("player x {} | y {}  camera x {} | y {}",
85                        player.1.x,
86                        player.1.y, 
87                        camera.position.x,
88                        camera.position.y,
89                    ),
90                    Some(Color::Red),
91                    None,
92                );
93
94                // Status border
95                let status_border = Border::new("╭─╮│╯─╰│", Some(Color::White), None);
96
97                status_viewport.swap_buffers();
98                status_viewport.draw_widget(&status_border, ScreenPos::zero());
99                status_viewport.draw_widget(&status, ScreenPos::new(1, 1));
100                let _ = renderer.render(&mut status_viewport);
101
102                // Render and swap the buffers so there is no 
103                // residual characters
104                let _ = renderer.render(&mut viewport);
105                viewport.swap_buffers();
106            }
107            Event::Key(KeyEvent { code: KeyCode::Esc, ..  }) => break,
108            Event::Key(KeyEvent { code: kc, .. }) => {
109                match kc {
110                    KeyCode::Left => { player.1.x -= 1; }
111                    KeyCode::Right => { player.1.x += 1; }
112                    KeyCode::Up => { player.1.y -= 1; }
113                    KeyCode::Down => { player.1.y += 1; }
114                    _ => {}
115                }
116            }
117            Event::Resize(_w, _h) => {}
118        }
119    }
120}

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> 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, 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.