Struct ParamInfos

pub struct ParamInfos<'a> { /* private fields */ }

Infos of a Material. This includes all global shader variables and textures. Warning, you have to be cautious when settings some infos https://stereokit.net/Pages/StereoKit/Material/GetAllParamInfo.html

see also Material::get_all_param_info ParamInfo

Examples

use stereokit_rust::{material::{Material, MaterialParam, Cull},
                     mesh::Mesh, maths::{Vec3, Vec4, Matrix}};

let cube = Mesh::cube();
let mut material_cube = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
material_cube.face_cull(Cull::Front).tex_transform(Vec4::new(0.0, 0.0, 0.04, 0.04));
let mut param_infos = material_cube.get_all_param_info();
assert!(param_infos.has_param("line_color", MaterialParam::Vec3), "line_color is missing");
assert_eq!(param_infos.get_float("edge_pos"), 1.5);

// Change of unusual values that are not listed in Material
param_infos .set_float("edge_pos", 0.5)
            .set_vector3("line_color", Vec3::new(0.54, 0.54, 0.20));

filename_scr = "screenshots/param_infos.jpeg";
test_screenshot!( // !!!! Get a proper main loop !!!!
    cube.draw(token, &material_cube, Matrix::IDENTITY, None, None);
);

Implementations

impl<'a> ParamInfos<'a>

pub fn from(material: &'a Material) -> ParamInfos<'a>

helper to get the infos with only a material https://stereokit.net/Pages/StereoKit/Material/GetAllParamInfo.html

• material - the material to get the param info from.

see also Material::get_all_param_info

Examples

use stereokit_rust::material::{Material, MaterialParam, ParamInfos};

let mut material_cube = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = ParamInfos::from(&material_cube);
assert!(param_infos.has_param("line_color", MaterialParam::Vec3), "line_color is missing");
assert_eq!(param_infos.get_float("edge_pos"), 1.5);

pub fn has_param<S: AsRef<str>>(&self, name: S, type_: MaterialParam) -> bool

Only way to see if a shader has a given parameter if you do not iterate over parameters. https://stereokit.net/Pages/StereoKit/Material.html

• name: The name of the parameter to check for.

see also material_has_param

Examples

use stereokit_rust::material::{Material, MaterialParam, ParamInfos};

let mut material_cube = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = ParamInfos::from(&material_cube);
assert!(param_infos.has_param("line_color", MaterialParam::Vec3), "line_color is missing");
assert!(param_infos.has_param("edge_pos", MaterialParam::Float),   "edge_pos is missing");

pub unsafe fn set_data<S: AsRef<str>>( &mut self, name: S, type_info: MaterialParam, value: *mut c_void, ) -> &mut Self

This allows you to set more complex shader data types such as structs. Note the SK doesn’t guard against setting data of the wrong size here, so pay extra attention to the size of your data here, and ensure it matched up with the shader! Consider using ParamInfos::set_data_with_id if you have to change the data type often (i.e. in the main loop). https://stereokit.net/Pages/StereoKit/Material/SetData.html

• name - The name of the parameter to set
• type_info - The type of the data being set.
• value - A pointer to the data being set.

see also material_set_param ParamInfos::set_data_with_id

Safety

Be sure of the data you want to modify this way.

Examples

use stereokit_rust::material::{Material, MaterialParam};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
// an odd way to do : material.color_tint(...);
let mut new_color: std::vec::Vec<f32>  = vec![1.0, 0.5, 0.2, 1.0];
unsafe{
    param_infos.set_data("color", MaterialParam::Color128,
                         new_color.as_ptr() as *mut std::ffi::c_void);
}
assert_eq!( param_infos.get_color("color"),
            util::Color128::new(1.0, 0.5, 0.2, 1.0));

pub unsafe fn set_data_with_id( &mut self, id: IdHashT, type_info: MaterialParam, value: *mut c_void, ) -> &mut Self

Add an info value (identified with an id) to the shader of this material. Be sure of using a pointer ‘value’ corresponding to the right type ‘type_info’ https://stereokit.net/Pages/StereoKit/Material/SetData.html

• id - the hash_fnv64_string value of the name of the parameter.
• type_info - the type of the parameter you want to set.
• value - a pointer to the data you want to set.

see also material_set_param_id ParamInfos::set_data

Safety

Be sure of the data you want to modify this way.

Examples

use stereokit_rust::{material::{Material, MaterialParam, Cull},
                     mesh::Mesh, maths::{Vec3, Vec4, Matrix}, util::Hash};

let cube = Mesh::cube();
let mut material_cube = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
material_cube.face_cull(Cull::Front).tex_transform(Vec4::new(0.0, 0.0, 0.04, 0.04));
let mut param_infos = material_cube.get_all_param_info();
// an odd way to do : material.color_tint(...);
let mut new_color: std::vec::Vec<f32>  = vec![0.2, 0.2, 0.9, 1.0];
let hash_color = Hash::string("color");

filename_scr = "screenshots/param_infos_with_id.jpeg";
test_screenshot!( // !!!! Get a proper main loop !!!!
    unsafe{
        param_infos.set_data_with_id(hash_color, MaterialParam::Color128,
                         new_color.as_ptr() as *mut std::ffi::c_void);
    }
    cube.draw(token, &material_cube, Matrix::IDENTITY, None, None);
);

pub fn set_bool<S: AsRef<str>>(&mut self, name: S, value: bool) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetBool.html

• name - Name of the shader parameter.
• value - The new value to set.

see also material_set_bool

Examples

use stereokit_rust::material::{Material, MaterialParam};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
param_infos.set_bool("use_occlusion", true);

assert_eq!( param_infos.get_bool("use_occlusion"),true);

pub fn set_color<S: AsRef<str>>( &mut self, name: S, color_gamma: impl Into<Color128>, ) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetColor.html

• name - Name of the shader parameter.
• color_gamma - The gamma space color for the shader to use.

see also material_set_color

Examples

use stereokit_rust::{material::{Material, MaterialParam},util::Color128};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
let new_color = Color128::new(1.0, 0.5, 0.2, 1.0);
// same as Material::color_tint(new_color);
param_infos.set_color("color", new_color);  

assert_eq!( param_infos.get_color("color"),new_color.to_linear() );

pub fn set_float<S: AsRef<str>>(&mut self, name: S, value: f32) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetFloat.html

• name - The name of the parameter to set.
• value - The value to set for the parameter.

see also material_set_float

Examples

use stereokit_rust::material::{Material, MaterialParam};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
param_infos.set_float("edge_pos", 0.18);

assert_eq!( param_infos.get_float("edge_pos"), 0.18);

pub fn set_int<S: AsRef<str>>(&mut self, name: S, values: &[i32]) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetInt.html

• name - the name of the parameter to set
• value - up to 4 integer values

see also material_set_int see also material_set_int2 see also material_set_int3 see also material_set_int4

Examples

use stereokit_rust::material::{Material, MaterialParam};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
let new_factors = vec![302,50,20,10];
param_infos.set_int("size_factors", new_factors.as_slice());

assert_eq!( param_infos.get_int_vector("size_factors", MaterialParam::Int4).unwrap(), new_factors);

pub fn set_uint<S: AsRef<str>>(&mut self, name: S, values: &[u32]) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! Warning, this may work on Int values as you can see in the examples. https://stereokit.net/Pages/StereoKit/Material/SetUInt.html

• name - the name of the parameter to set
• value : up to 4 unsigned integer values

see also material_set_uint see also material_set_uint2 see also material_set_uint3 see also material_set_uint4

Examples

use stereokit_rust::material::{Material, MaterialParam};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
assert_eq!( param_infos.get_uint_vector("size_factors", MaterialParam::UInt4).unwrap(), vec![300, 4294967196, 50, 25]);
let new_factors = vec![303,502,201,100];
param_infos.set_uint("size_factors", new_factors.as_slice());

assert!( param_infos.has_param("size_factors", MaterialParam::UInt4),"size_factors should be here");
assert_eq!( param_infos.get_uint_vector("size_factors", MaterialParam::UInt4).unwrap(), new_factors);

pub fn set_matrix<S: AsRef<str>>( &mut self, name: S, value: impl Into<Matrix>, ) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetMatrix.html

• name - The name of the parameter to set.
• value - The Matrix to set for the parameter.

see also material_set_matrix

Examples

use stereokit_rust::{material::{Material, MaterialParam}, maths::{Vec3, Matrix}};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
assert_eq!( param_infos.get_matrix("useless"), Matrix::NULL );
let new_matrix = Matrix::t( Vec3::new(1.0, 2.0, 3.0));
param_infos.set_matrix("useless", new_matrix);

assert!( param_infos.has_param("useless", MaterialParam::Matrix),"size_factors should be here");
assert_eq!( param_infos.get_matrix("useless"), new_matrix);

pub fn set_texture<S: AsRef<str>>( &mut self, name: S, value: impl AsRef<Tex>, ) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetTexture.html

• name - the name of the parameter to set
• value - the Tex to set for the parameter

see also material_set_texture

Examples

use stereokit_rust::{material::{Material, MaterialParam}, tex::{Tex}};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
assert_ne!( param_infos.get_texture("metal").unwrap(), Tex::default() );
let metal_tex = Tex::from_file("textures/open_gltf.jpeg", true, None)
                   .expect("tex should be created");
param_infos.set_texture("metal", &metal_tex);
assert_eq!( param_infos.get_texture("metal").unwrap(), metal_tex );

pub fn set_vector2<S: AsRef<str>>( &mut self, name: S, value: impl Into<Vec2>, ) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetVector.html

• name - the name of the parameter to set
• value - the Vec2 to set for the parameter

see also material_set_vector2

Examples

use stereokit_rust::{material::{Material, MaterialParam}, maths::Vec2};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
assert_eq!( param_infos.get_vector2("edge_limit"), Vec2::new(0.1, 0.9) );
let new_vec2 = Vec2::new(0.15, 0.85);
param_infos.set_vector2("edge_limit", new_vec2);
assert_eq!( param_infos.get_vector2("edge_limit"), new_vec2);

pub fn set_vector3<S: AsRef<str>>( &mut self, name: S, value: impl Into<Vec3>, ) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetVector.html

• name - the name of the parameter to set
• value - the Vec3 to set for the parameter

see also material_set_vector2

Examples

use stereokit_rust::{material::{Material, MaterialParam}, maths::Vec3};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
assert_eq!( param_infos.get_vector3("line_color"), Vec3::new(0.84, 0.84, 0.84) );
let new_vec3 = Vec3::new(0.75, 0.75, 0.75);
param_infos.set_vector3("line_color", new_vec3);
assert_eq!( param_infos.get_vector3("line_color"), new_vec3);

pub fn set_vector4<S: AsRef<str>>( &mut self, name: S, value: impl Into<Vec4>, ) -> &mut Self

Sets a shader parameter with the given name to the provided value. If no parameter is found, nothing happens, and the value is not set! https://stereokit.net/Pages/StereoKit/Material/SetVector.html

• name- The name of the parameter to set.
• value - the Vec4 to set for the parameter

see also material_set_vector4

Examples

use stereokit_rust::{material::Material, maths::Vec4};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
assert_eq!( param_infos.get_vector4("tex_trans"), Vec4::new(0.0, 0.0, 0.1,0.1) );

let new_vec4 = Vec4::new(0.0, 0.0, 0.75, 0.75);
// same as material.tex_transform(new_vec4)
param_infos.set_vector4("tex_trans", new_vec4);
assert_eq!( param_infos.get_vector4("tex_trans"), new_vec4);

pub fn get_bool<S: AsRef<str>>(&self, name: S) -> bool

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of ‘false’ will be returned. https://stereokit.net/Pages/StereoKit/Material/GetBool.html

• name - The name of the shader parameter to get.

see also material_get_bool see example in ParamInfos::set_bool

pub fn get_float<S: AsRef<str>>(&self, name: S) -> f32

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of ‘0’ will be returned. https://stereokit.net/Pages/StereoKit/Material/GetFloat.html

• name - The name of the shader parameter to get.

see also material_get_float see example in ParamInfos::set_float

pub fn get_vector2<S: AsRef<str>>(&self, name: S) -> Vec2

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of Vec2::ZERO will be returned. https://stereokit.net/Pages/StereoKit/Material/GetVector2.html

• name - The name of the shader parameter to get.

see also material_get_vector2 see example in ParamInfos::set_vector2

pub fn get_vector3<S: AsRef<str>>(&self, name: S) -> Vec3

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of Vec3::ZERO will be returned. https://stereokit.net/Pages/StereoKit/Material/GetVector3.html

• name - The name of the shader parameter to get.

see also material_get_vector3 see example in ParamInfos::set_vector3

pub fn get_vector4<S: AsRef<str>>(&self, name: S) -> Vec4

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of Vec4::ZERO will be returned. https://stereokit.net/Pages/StereoKit/Material/GetVector4.html

• name - The name of the shader parameter to get.

see also material_get_vector4 see example in ParamInfos::set_vector4

pub fn get_color<S: AsRef<str>>(&self, name: S) -> Color128

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of Color128::WHITE will be returned. Warning: This function returns a gamma color. https://stereokit.net/Pages/StereoKit/Material/GetColor.html

• name - The name of the shader parameter to get.

see also material_get_color see example in ParamInfos::set_color

pub fn get_int<S: AsRef<str>>(&self, name: S) -> i32

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of ‘0’ will be returned. https://stereokit.net/Pages/StereoKit/Material/GetInt.html

• name - The name of the shader parameter to get.

see also [material_get_int] see example in [ParamInfos::set_int`]

pub fn get_int_vector<S: AsRef<str>>( &self, name: S, type_info: MaterialParam, ) -> Option<Vec<i32>>

Get int vector using unsafe material_get_param function

• name - The name of the shader parameter to get.
• type_info - The type of the shader parameter to get: Int, Int2, Int3 or Int4

see example in ParamInfos::set_int

pub fn get_uint<S: AsRef<str>>(&self, name: S) -> u32

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of ‘0’ will be returned. https://stereokit.net/Pages/StereoKit/Material/GetUInt.html

• name - The name of the shader parameter to get.

see also material_get_uint see example in ParamInfos::set_uint

pub fn get_uint_vector<S: AsRef<str>>( &self, name: S, type_info: MaterialParam, ) -> Option<Vec<u32>>

Get uint vector using unsafe material_get_param function

• name - The name of the shader parameter to get.
• type_info - The type of the shader parameter to get: UInt, UInt2, UInt3, UInt4.

see example in ParamInfos::set_uint

pub fn get_matrix<S: AsRef<str>>(&self, name: S) -> Matrix

Gets the value of a shader parameter with the given name. If no parameter is found, a default value of Matrix.Identity will be returned. https://stereokit.net/Pages/StereoKit/Material/GetMatrix.html

• name - The name of the parameter to get.

see also material_get_matrix see example in ParamInfos::set_matrix

pub fn get_texture<S: AsRef<str>>(&self, name: S) -> Option<Tex>

Gets the value of a shader parameter with the given name. If no parameter is found,None will be returned. https://stereokit.net/Pages/StereoKit/Material/GetTexture.html

• name - The name of the parameter to get.

see also material_get_texture see example in ParamInfos::set_texture

pub fn get_data<S: AsRef<str>>( &self, name: S, type_info: MaterialParam, ) -> Option<*mut c_void>

Get an info value of the shader of this material https://stereokit.net/Pages/StereoKit/Material.html

• name - The name of the parameter to get.
• type_info - The type of the parameter to get.

see also ParamInfo material_get_param

Examples

use stereokit_rust::material::{Material, MaterialParam};

let mut material = Material::from_file("shaders/brick_pbr.hlsl.sks", None).unwrap();
let mut param_infos = material.get_all_param_info();
if let Some(out_value) = param_infos.get_data("size_factors", MaterialParam::Int4) {
    let vec4 = unsafe { std::ptr::read(out_value as *const [i32; 4]).to_vec() };
    assert_eq!( vec4, vec![300,-100,50,25] );
} else { panic!("Failed to size_factors Int4");}

see ParamInfos::set_data

pub fn get_data_with_id( &self, id: IdHashT, type_info: MaterialParam, ) -> Option<*mut c_void>

Get an info value (identified with an id) of the shader of this material https://stereokit.net/Pages/StereoKit/Material.html

• id - the crate::util::Hash::string value of the name of the parameter.
• type_info - the type of the parameter.

Returns a pointer to the value that will be filled in if the parameter is found. see also ParamInfo material_get_param_id ParamInfos::set_data_with_id

pub fn get_count(&self) -> i32

Get the number of infos for this node https://stereokit.net/Pages/StereoKit/Material/ParamCount.html

see also material_get_param_count

Examples

use stereokit_rust::material::Material;

let mut material = Material::unlit();
let mut param_infos = material.get_all_param_info();
assert_eq!( param_infos.get_count(), 3);

pub fn string_of(&self, info: &ParamInfo) -> String

Get the string value of the given ParamInfo

Examples

use stereokit_rust::material::Material;

let mut material = Material::unlit();
let mut param_infos_iter = material.get_all_param_info();
let mut param_infos = material.get_all_param_info();
for param in param_infos_iter {
    match (param.get_name()) {
        "color" =>
            assert_eq!(param_infos.string_of(&param), "r:1, g:1, b:1, a:1"),
        "tex_trans" =>
            assert_eq!(param_infos.string_of(&param), "[x:0, y:0, z:1, w:1]"),
        "diffuse" =>
            assert_eq!(param_infos.string_of(&param), "Texture data..."),
       otherwise =>
            panic!("Unknown param type: {}", otherwise)
    }
}

Trait Implementations

impl Iterator for ParamInfos<'_>

fn next(&mut self) -> Option<Self::Item>

get all the param info

see also material_get_param_info material_get_param_count material_get_param

type Item = ParamInfo

The type of the elements being iterated over.

fn next_chunk<const N: usize>( &mut self, ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator.

fn count(self) -> usize

where Self: Sized,

Consumes the iterator, counting the number of iterations and returning it.

fn last(self) -> Option<Self::Item>

where Self: Sized,

Consumes the iterator, returning the last element.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements.

fn nth(&mut self, n: usize) -> Option<Self::Item>

Returns the nth element of the iterator.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Creates an iterator starting at the same point, but stepping by the given amount at each iteration.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>

where Self: Sized, U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs.

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>

where Self: Sized, G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator between adjacent items of the original iterator.

fn map<B, F>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each element.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Item),

Calls a closure on each element of an iterator.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element should be yielded.

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both filters and maps.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Creates an iterator which gives the current iteration count as well as the next value.

fn peekable(self) -> Peekable<Self>

where Self: Sized,

Creates an iterator which can use the peek and peek_mut methods to look at the next element of the iterator without consuming it. See their documentation for more information.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate.

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: FnMut(Self::Item) -> Option<B>,

Creates an iterator that both yields elements based on a predicate and maps.

fn skip(self, n: usize) -> Skip<Self>

where Self: Sized,

Creates an iterator that skips the first n elements.

fn take(self, n: usize) -> Take<Self>

where Self: Sized,

Creates an iterator that yields the first n elements, or fewer if the underlying iterator ends sooner.

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,

An iterator adapter which, like fold, holds internal state, but unlike fold, produces a new iterator.

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>

where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure.

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

where Self: Sized, F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function f for each contiguous window of size N over self and returns an iterator over the outputs of f. Like slice::windows(), the windows during mapping overlap as well.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Creates an iterator which ends after the first None.

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Iterator.

fn collect<B>(self) -> B

where B: FromIterator<Self::Item>, Self: Sized,

Transforms an iterator into a collection.

fn collect_into<E>(self, collection: &mut E) -> &mut E

where E: Extend<Self::Item>, Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection.

fn partition<B, F>(self, f: F) -> (B, B)

where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,

Consumes an iterator, creating two collections from it.

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate, such that all those that return true precede all those that return false.

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,

An iterator method that applies a function as long as it returns successfully, producing a single, final value.

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the iterator, stopping at the first error and returning that error.

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Item) -> B,

Folds every element into an accumulator by applying an operation, returning the final result.

fn reduce<F>(self, f: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing operation.

fn try_reduce<R>( &mut self, f: impl FnMut(Self::Item, Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType

where Self: Sized, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the closure returns a failure, the failure is propagated back to the caller immediately.

fn all<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if every element of the iterator matches a predicate.

fn any<F>(&mut self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> bool,

Tests if any element of the iterator matches a predicate.

fn find<P>(&mut self, predicate: P) -> Option<Self::Item>

where Self: Sized, P: FnMut(&Self::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate.

fn find_map<B, F>(&mut self, f: F) -> Option<B>

where Self: Sized, F: FnMut(Self::Item) -> Option<B>,

Applies function to the elements of iterator and returns the first non-none result.

fn try_find<R>( &mut self, f: impl FnMut(&Self::Item) -> R, ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType

where Self: Sized, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns the first true result or the first error.

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Item) -> bool,

Searches for an element in an iterator, returning its index.

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the specified function.

fn max_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the specified comparison function.

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>

where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the specified function.

fn min_by<F>(self, compare: F) -> Option<Self::Item>

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the specified comparison function.

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)

where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers.

fn copied<'a, T>(self) -> Copied<Self>

where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements.

fn cloned<'a, T>(self) -> Cloned<Self>

where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements.

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>

where Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time.

fn sum<S>(self) -> S

where Self: Sized, S: Sum<Self::Item>,

Sums the elements of an iterator.

fn product<P>(self) -> P

where Self: Sized, P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn partial_cmp<I>(self, other: I) -> Option<Ordering>

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Lexicographically compares the PartialOrd elements of this Iterator with those of another. The comparison works like short-circuit evaluation, returning a result without comparing the remaining elements. As soon as an order can be determined, the evaluation stops and a result is returned.

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those of another with respect to the specified comparison function.

fn eq<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are equal to those of another.

fn eq_by<I, F>(self, other: I, eq: F) -> bool

where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of another with respect to the specified equality function.

fn ne<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are not equal to those of another.

fn lt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less than those of another.

fn le<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically less or equal to those of another.

fn gt<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than those of another.

fn ge<I>(self, other: I) -> bool

where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,

Determines if the elements of this Iterator are lexicographically greater than or equal to those of another.

fn is_sorted_by<F>(self, compare: F) -> bool

where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function.

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction function.