Struct RCHandle

pub struct RCHandle<Native>(/* private fields */)
where
    Native: NativeRefCounted;

A wrapper type represented by a reference counted pointer to the native type.

Implementations

impl RCHandle<SkBlender>

pub fn mode(mode: SkBlendMode) -> RCHandle<SkBlender>

Create a blender that implements the specified BlendMode.

impl RCHandle<SkColorFilter>

ColorFilters are optional objects in the drawing pipeline. When present in a paint, they are called with the “src” colors, and return new colors, which are then passed onto the next stage (either ImageFilter or Xfermode).

All subclasses are required to be reentrant-safe : it must be legal to share the same instance between several threads.

pub fn to_a_color_mode(&self) -> Option<(Color, SkBlendMode)>

If the filter can be represented by a source color plus Mode, this returns the color and mode appropriately. If not, this returns None and ignores the parameters.

pub fn to_a_color_matrix(&self) -> Option<[f32; 20]>

If the filter can be represented by a 5x4 matrix, this returns the matrix appropriately. If not, this returns None and ignores the parameter.

pub fn is_alpha_unchanged(&self) -> bool

Returns true if the filter is guaranteed to never change the alpha of a color it filters.

pub fn filter_color(&self, color: impl Into<Color>) -> Color

👎Deprecated since 0.79.0: Use filter_color4f()

pub fn filter_color4f( &self, color: impl Into<Color4f>, src_color_space: Option<&RCHandle<SkColorSpace>>, dst_color_space: Option<&RCHandle<SkColorSpace>>, ) -> Color4f

Converts the src color (in src colorspace), into the dst colorspace, then applies this filter to it, returning the filtered color in the dst colorspace.

pub fn composed( &self, inner: impl Into<RCHandle<SkColorFilter>>, ) -> Option<RCHandle<SkColorFilter>>

Construct a color filter whose effect is to first apply the inner filter and then apply this filter, applied to the output of the inner filter.

result = this(inner(…))

pub fn with_working_color_space( &self, color_space: impl Into<RCHandle<SkColorSpace>>, ) -> Option<RCHandle<SkColorFilter>>

Return a color filter that will compute this filter in a specific color space. By default all filters operate in the destination (surface) color space. This allows filters like Blend and Matrix, or runtime color filters to perform their math in a known space.

impl RCHandle<SkColorSpace>

pub fn new_srgb() -> RCHandle<SkColorSpace>

pub fn new_srgb_linear() -> RCHandle<SkColorSpace>

pub fn new_cicp( primaries: SkNamedPrimaries_CicpId, transfer_characteristics: SkNamedTransferFn_CicpId, ) -> Option<RCHandle<SkColorSpace>>

pub fn to_xyzd50_hash(&self) -> XYZD50Hash

pub fn with_linear_gamma(&self) -> RCHandle<SkColorSpace>

pub fn with_srgb_gamma(&self) -> RCHandle<SkColorSpace>

pub fn with_color_spin(&self) -> RCHandle<SkColorSpace>

pub fn is_srgb(&self) -> bool

pub fn serialize(&self) -> RCHandle<SkData>

pub fn deserialize(data: impl Into<RCHandle<SkData>>) -> RCHandle<SkColorSpace>

pub fn transfer_fn(&self) -> ColorSpaceTransferFn

pub fn inv_transfer_fn(&self) -> ColorSpaceTransferFn

pub fn transfer_fn_hash(&self) -> u32

pub fn hash(&self) -> u64

impl RCHandle<SkColorTable>

pub fn new(table: &[u8; 256]) -> RCHandle<SkColorTable>

Creates a new ColorTable with ‘table’ used for all four channels. The table is copied into the ColorTable.

pub fn new_per_channel<'a>( table_a: impl Into<Option<&'a [u8; 256]>>, table_r: impl Into<Option<&'a [u8; 256]>>, table_g: impl Into<Option<&'a [u8; 256]>>, table_b: impl Into<Option<&'a [u8; 256]>>, ) -> Option<RCHandle<SkColorTable>>

pub fn alpha_table(&self) -> &[u8; 256]

pub fn red_table(&self) -> &[u8; 256]

pub fn green_table(&self) -> &[u8; 256]

pub fn blue_table(&self) -> &[u8; 256]

impl RCHandle<SkContourMeasure>

pub fn length(&self) -> f32

pub fn pos_tan(&self, distance: f32) -> Option<(Point, Point)>

pub fn get_matrix( &self, distance: f32, flags: impl Into<Option<MatrixFlags>>, ) -> Option<Matrix>

pub fn segment( &self, start_d: f32, stop_d: f32, start_with_move_to: bool, ) -> Option<Handle<SkPath>>

pub fn is_closed(&self) -> bool

pub fn verbs(&self) -> ForwardVerbIterator<'_>

impl RCHandle<SkData>

pub fn size(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn as_bytes(&self) -> &[u8]

pub fn copy_range(&self, offset: usize, buffer: &mut [u8]) -> &RCHandle<SkData>

pub fn new_copy(data: &[u8]) -> RCHandle<SkData>

pub unsafe fn new_bytes(data: &[u8]) -> RCHandle<SkData>

Constructs Data from a given byte slice without copying it.

Users must make sure that the underlying slice will outlive the lifetime of the Data.

pub unsafe fn new_uninitialized(length: usize) -> RCHandle<SkData>

pub fn new_zero_initialized(length: usize) -> RCHandle<SkData>

pub fn new_subset( data: &RCHandle<SkData>, offset: usize, length: usize, ) -> RCHandle<SkData>

pub fn new_str(str: impl AsRef<str>) -> RCHandle<SkData>

Constructs Data from a copy of a &str.

Functions that use Data as a string container usually expect it to contain a c-string including the terminating 0 byte, so this function converts the Rust str to a CString and calls Self::new_cstr().

pub fn new_cstr(cstr: &CStr) -> RCHandle<SkData>

Constructs Data from a &CStr by copying its contents.

pub fn from_filename(path: impl AsRef<Path>) -> Option<RCHandle<SkData>>

Create a new Data referencing the file with the specified path. If the file cannot be opened, the path contains 0 bytes, or the path is not valid UTF-8, this returns None.

This function opens the file as a memory mapped file for the lifetime of Data returned.

pub fn from_stream(stream: impl Read, size: usize) -> Option<RCHandle<SkData>>

Attempt to read size bytes into a Data. If the read succeeds, return the data, else return None. Either way the stream’s cursor may have been changed as a result of calling read().

pub fn new_empty() -> RCHandle<SkData>

impl RCHandle<SkDataTable>

pub fn is_empty(&self) -> bool

pub fn count(&self) -> usize

pub fn at_size(&self, index: usize) -> usize

pub fn at(&self, index: usize) -> &[u8]

pub unsafe fn at_t<T>(&self, index: usize) -> &[T]

where T: Copy,

pub fn at_str(&self, index: usize) -> &CStr

pub fn new_empty() -> RCHandle<SkDataTable>

pub fn from_slices(slices: &[&[u8]]) -> RCHandle<SkDataTable>

pub fn from_slice<T>(slice: &[T]) -> RCHandle<SkDataTable>

where T: Copy,

pub fn iter(&self) -> Iter<'_>

impl RCHandle<SkDrawable>

pub fn draw(&mut self, canvas: &Canvas, matrix: Option<&Matrix>)

pub fn draw_at(&mut self, canvas: &Canvas, point: impl Into<Point>)

pub fn snap_gpu_draw_handler( &mut self, api: GrBackendApi, matrix: &Matrix, clip_bounds: impl Into<IRect>, buffer_info: &Handle<SkImageInfo>, ) -> Option<RefHandle<SkDrawable_GpuDrawHandler>>

pub fn make_picture_snapshot(&mut self) -> RCHandle<SkPicture>

pub fn generation_id(&mut self) -> u32

pub fn bounds(&mut self) -> Rect

pub fn approximate_bytes_used(&mut self) -> usize

pub fn notify_drawing_changed(&mut self)

impl RCHandle<SkFontStyleSet>

pub fn count(&mut self) -> usize

pub fn style(&mut self, index: usize) -> (FontStyle, Option<String>)

pub fn new_typeface(&mut self, index: usize) -> Option<RCHandle<SkTypeface>>

pub fn match_style( &mut self, pattern: FontStyle, ) -> Option<RCHandle<SkTypeface>>

pub fn new_empty() -> RCHandle<SkFontStyleSet>

impl RCHandle<SkFontMgr>

pub fn new() -> RCHandle<SkFontMgr>

pub fn empty() -> RCHandle<SkFontMgr>

pub fn count_families(&self) -> usize

pub fn family_name(&self, index: usize) -> String

pub fn family_names(&self) -> impl Iterator<Item = String> + use<'_>

pub fn new_styleset(&self, index: usize) -> RCHandle<SkFontStyleSet>

👎Deprecated since 0.41.0: Use new_style_set

pub fn new_style_set(&self, index: usize) -> RCHandle<SkFontStyleSet>

pub fn match_family( &self, family_name: impl AsRef<str>, ) -> RCHandle<SkFontStyleSet>

pub fn match_family_style( &self, family_name: impl AsRef<str>, style: FontStyle, ) -> Option<RCHandle<SkTypeface>>

pub fn match_family_style_character( &self, family_name: impl AsRef<str>, style: FontStyle, bcp_47: &[&str], character: i32, ) -> Option<RCHandle<SkTypeface>>

pub fn match_face_style( &self, _typeface: impl AsRef<RCHandle<SkTypeface>>, _style: FontStyle, ) -> !

👎Deprecated since 0.35.0: Removed without replacement

pub fn new_from_data( &self, bytes: &[u8], ttc_index: impl Into<Option<usize>>, ) -> Option<RCHandle<SkTypeface>>

pub fn legacy_make_typeface<'a>( &self, family_name: impl Into<Option<&'a str>>, style: FontStyle, ) -> Option<RCHandle<SkTypeface>>

impl RCHandle<SkImage>

pub fn from_raster_data( info: &Handle<SkImageInfo>, pixels: impl Into<RCHandle<SkData>>, row_bytes: usize, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use images::raster_from_data()

Creates Image from ImageInfo, sharing pixels.

Image is returned if ImageInfo is valid. Valid ImageInfo parameters include: dimensions are greater than zero; each dimension fits in 29 bits; ColorType and AlphaType are valid, and ColorType is not ColorType::Unknown; rowBytes are large enough to hold one row of pixels; pixels is not nullptr, and contains enough data for Image.

• info contains width, height, AlphaType, ColorType, ColorSpace
• pixels address or pixel storage
• rowBytes size of pixel row or larger

Returns: Image sharing pixels, or None

pub fn from_bitmap(bitmap: &Handle<SkBitmap>) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use images::raster_from_bitmap()

Creates Image from bitmap, sharing or copying bitmap pixels. If the bitmap is marked immutable, and its pixel memory is shareable, it may be shared instead of copied.

Image is returned if bitmap is valid. Valid Bitmap parameters include: dimensions are greater than zero; each dimension fits in 29 bits; ColorType and AlphaType are valid, and ColorType is not ColorType::Unknown; row bytes are large enough to hold one row of pixels; pixel address is not null.

• bitmap ImageInfo, row bytes, and pixels

Returns: created Image, or None

example: https://fiddle.skia.org/c/@Image_MakeFromBitmap

pub fn from_generator( image_generator: RefHandle<SkImageGenerator>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use images::deferred_from_generator()

Creates Image from data returned by image_generator. Generated data is owned by Image and may not be shared or accessed.

Image is returned if generator data is valid. Valid data parameters vary by type of data and platform.

imageGenerator may wrap Picture data, codec data, or custom data.

• image_generator stock or custom routines to retrieve Image

Returns: created Image, or None

pub fn from_encoded( data: impl Into<RCHandle<SkData>>, ) -> Option<RCHandle<SkImage>>

See Self::from_encoded_with_alpha_type()

pub fn from_encoded_with_alpha_type( data: impl Into<RCHandle<SkData>>, alpha_type: impl Into<Option<SkAlphaType>>, ) -> Option<RCHandle<SkImage>>

Return an image backed by the encoded data, but attempt to defer decoding until the image is actually used/drawn. This deferral allows the system to cache the result, either on the CPU or on the GPU, depending on where the image is drawn. If memory is low, the cache may be purged, causing the next draw of the image to have to re-decode.

If alphaType is None, the image’s alpha type will be chosen automatically based on the image format. Transparent images will default to AlphaType::Premul. If alphaType contains AlphaType::Premul or AlphaType::Unpremul, that alpha type will be used. Forcing opaque (passing AlphaType::Opaque) is not allowed, and will return nullptr.

This is similar to decode_to_{raster,texture}, but this method will attempt to defer the actual decode, while the decode_to… method explicitly decode and allocate the backend when the call is made.

If the encoded format is not supported, None is returned.

• encoded the encoded data

Returns: created Image, or None

example: https://fiddle.skia.org/c/@Image_MakeFromEncoded

pub fn decode_to_raster(_encoded: &[u8], _subset: impl Into<Option<IRect>>) -> !

👎Deprecated since 0.35.0: Removed without replacement

pub fn new_raster_from_compressed( data: impl Into<RCHandle<SkData>>, dimensions: impl Into<ISize>, ty: SkTextureCompressionType, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use images::raster_from_compressed_texture_data()

Creates a CPU-backed Image from compressed data.

This method will decompress the compressed data and create an image wrapping it. Any mipmap levels present in the compressed data are discarded.

• data compressed data to store in Image
• width width of full Image
• height height of full Image
• ty type of compression used

Returns: created Image, or None

pub fn from_picture( picture: impl Into<RCHandle<SkPicture>>, dimensions: impl Into<ISize>, matrix: Option<&Matrix>, paint: Option<&Handle<SkPaint>>, bit_depth: SkImages_BitDepth, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use images::deferred_from_picture()

See Self::from_picture_with_props()

pub fn from_picture_with_props( picture: impl Into<RCHandle<SkPicture>>, dimensions: impl Into<ISize>, matrix: Option<&Matrix>, paint: Option<&Handle<SkPaint>>, bit_depth: SkImages_BitDepth, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, props: SurfaceProps, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use images::deferred_from_picture()

Creates Image from picture. Returned Image width and height are set by dimensions. Image draws picture with matrix and paint, set to bitDepth and colorSpace.

If matrix is None, draws with identity Matrix. If paint is None, draws with default Paint. color_space may be None.

• picture stream of drawing commands
• dimensions width and height
• matrix Matrix to rotate, scale, translate, and so on; may be None
• paint Paint to apply transparency, filtering, and so on; may be None
• bitDepth 8-bit integer or 16-bit float: per component
• color_space range of colors; may be None
• props props to use when rasterizing the picture

Returns: created Image, or None

pub fn new_texture_from_compressed( context: &mut RCHandle<GrDirectContext>, data: RCHandle<SkData>, dimensions: impl Into<ISize>, ty: SkTextureCompressionType, mipmapped: impl Into<Option<skgpu_Mipmapped>>, is_protected: impl Into<Option<skgpu_Protected>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use gpu::images::texture_from_compressed_texture_data()

Creates a GPU-backed Image from compressed data.

This method will return an Image representing the compressed data. If the GPU doesn’t support the specified compression method, the data will be decompressed and then wrapped in a GPU-backed image.

Note: one can query the supported compression formats via gpu::RecordingContext::compressed_backend_format.

• context GPU context
• data compressed data to store in Image
• width width of full Image
• height height of full Image
• ty type of compression used
• mipmapped does ‘data’ contain data for all the mipmap levels?
• is_protected do the contents of ‘data’ require DRM protection (on Vulkan)?

Returns: created Image, or None

pub fn from_compressed( _context: &mut RCHandle<GrRecordingContext>, _data: RCHandle<SkData>, _dimensions: impl Into<ISize>, _ct: SkTextureCompressionType, ) -> !

👎Deprecated since 0.35.0: Removed without replacement

pub fn from_texture( context: &mut RCHandle<GrRecordingContext>, backend_texture: &RefHandle<GrBackendTexture>, origin: GrSurfaceOrigin, color_type: ColorType, alpha_type: SkAlphaType, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, ) -> Option<RCHandle<SkImage>>

Creates Image from GPU texture associated with context. GPU texture must stay valid and unchanged until texture_release_proc is called. texture_release_proc is passed release_context when Image is deleted or no longer refers to texture.

Image is returned if format of backend_texture is recognized and supported. Recognized formats vary by GPU back-end.

Note: When using a DDL recording context, texture_release_proc will be called on the GPU thread after the DDL is played back on the direct context.

• context GPU context
• backend_texture Texture residing on GPU
• origin Origin of backend_texture
• color_type Color type of the resulting image
• alpha_type Alpha type of the resulting image
• color_space This describes the color space of this image’s contents, as seen after sampling. In general, if the format of the backend texture is SRGB, some linear color_space should be supplied (e.g., ColorSpace::new_srgb_linear())). If the format of the backend texture is linear, then the color_space should include a description of the transfer function as well (e.g., ColorSpace::MakeSRGB).
• texture_release_proc Function called when texture can be released
• release_context State passed to texture_release_proc

Returns: Created Image, or None

pub fn from_pixmap_cross_context( context: &mut RCHandle<GrDirectContext>, pixmap: &Pixmap<'_>, build_mips: bool, limit_to_max_texture_size: impl Into<Option<bool>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.27.0: renamed, use new_cross_context_from_pixmap

pub fn new_cross_context_from_pixmap( context: &mut RCHandle<GrDirectContext>, pixmap: &Pixmap<'_>, build_mips: bool, limit_to_max_texture_size: impl Into<Option<bool>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use gpu::images::cross_context_texture_from_pixmap()

Creates Image from pixmap. Image is uploaded to GPU back-end using context.

Created Image is available to other GPU contexts, and is available across thread boundaries. All contexts must be in the same GPU share group, or otherwise share resources.

When Image is no longer referenced, context releases texture memory asynchronously.

ColorSpace of Image is determined by pixmap.color_space().

Image is returned referring to GPU back-end if context is not None, format of data is recognized and supported, and if context supports moving resources between contexts. Otherwise, pixmap pixel data is copied and Image as returned in raster format if possible; None may be returned. Recognized GPU formats vary by platform and GPU back-end.

• context GPU context
• pixmap ImageInfo, pixel address, and row bytes
• build_mips create Image as mip map if true
• limit_to_max_texture_size downscale image to GPU maximum texture size, if necessary

Returns: created Image, or None

pub fn from_adopted_texture( context: &mut RCHandle<GrRecordingContext>, backend_texture: &RefHandle<GrBackendTexture>, texture_origin: GrSurfaceOrigin, color_type: ColorType, alpha_type: impl Into<Option<SkAlphaType>>, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use gpu::images::adopt_texture_from()

Creates Image from backend_texture associated with context. backend_texture and returned Image are managed internally, and are released when no longer needed.

Image is returned if format of backend_texture is recognized and supported. Recognized formats vary by GPU back-end.

• context GPU context
• backend_texture texture residing on GPU
• texture_origin origin of backend_texture
• color_type color type of the resulting image
• alpha_type alpha type of the resulting image
• color_space range of colors; may be None

Returns: created Image, or None

pub fn from_yuva_textures( context: &mut RCHandle<GrRecordingContext>, yuva_textures: &Handle<GrYUVABackendTextures>, image_color_space: impl Into<Option<RCHandle<SkColorSpace>>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use gpu::images::texture_from_yuva_textures()

Creates an Image from YUV[A] planar textures. This requires that the textures stay valid for the lifetime of the image. The ReleaseContext can be used to know when it is safe to either delete or overwrite the textures. If ReleaseProc is provided it is also called before return on failure.

• context GPU context
• yuva_textures A set of textures containing YUVA data and a description of the data and transformation to RGBA.
• image_color_space range of colors of the resulting image after conversion to RGB; may be None
• texture_release_proc called when the backend textures can be released
• release_context state passed to texture_release_proc

Returns: created Image, or None

pub fn from_yuva_pixmaps( context: &mut RCHandle<GrRecordingContext>, yuva_pixmaps: &Handle<SkYUVAPixmaps>, build_mips: impl Into<Option<skgpu_Mipmapped>>, limit_to_max_texture_size: impl Into<Option<bool>>, image_color_space: impl Into<Option<RCHandle<SkColorSpace>>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.63.0: use gpu::images::texture_from_yuva_pixmaps()

Creates Image from crate::YUVAPixmaps.

The image will remain planar with each plane converted to a texture using the passed gpu::RecordingContext.

crate::YUVAPixmaps has a crate::YUVAInfo which specifies the transformation from YUV to RGB. The ColorSpace of the resulting RGB values is specified by image_color_space. This will be the ColorSpace reported by the image and when drawn the RGB values will be converted from this space into the destination space (if the destination is tagged).

Currently, this is only supported using the GPU backend and will fail if context is None.

crate::YUVAPixmaps does not need to remain valid after this returns.

• context GPU context
• pixmaps The planes as pixmaps with supported crate::YUVAInfo that specifies conversion to RGB.
• build_mips create internal YUVA textures as mip map if Yes. This is silently ignored if the context does not support mip maps.
• limit_to_max_texture_size downscale image to GPU maximum texture size, if necessary
• image_color_space range of colors of the resulting image; may be None

Returns: created Image, or None

pub fn from_nv12_textures_copy( _context: &mut RCHandle<GrDirectContext>, _yuv_color_space: SkYUVColorSpace, _nv12_textures: &[RefHandle<GrBackendTexture>; 2], _image_origin: GrSurfaceOrigin, _image_color_space: impl Into<Option<RCHandle<SkColorSpace>>>, ) -> !

👎Deprecated since 0.37.0: Removed without replacement

pub fn image_info(&self) -> &Handle<SkImageInfo>

Returns a ImageInfo describing the width, height, color type, alpha type, and color space of the Image.

Returns: image info of Image.

pub fn width(&self) -> i32

Returns pixel count in each row.

Returns: pixel width in Image

pub fn height(&self) -> i32

Returns pixel row count.

Returns: pixel height in Image

pub fn dimensions(&self) -> ISize

Returns ISize { width(), height() }.

Returns: integral size of width() and height()

pub fn bounds(&self) -> IRect

Returns IRect { 0, 0, width(), height() }.

Returns: integral rectangle from origin to width() and height()

pub fn unique_id(&self) -> u32

Returns value unique to image. Image contents cannot change after Image is created. Any operation to create a new Image will receive generate a new unique number.

Returns: unique identifier

pub fn alpha_type(&self) -> SkAlphaType

Returns AlphaType.

AlphaType returned was a parameter to an Image constructor, or was parsed from encoded data.

Returns: AlphaType in Image

example: https://fiddle.skia.org/c/@Image_alphaType

pub fn color_type(&self) -> ColorType

Returns ColorType if known; otherwise, returns ColorType::Unknown.

Returns: ColorType of Image

example: https://fiddle.skia.org/c/@Image_colorType

pub fn color_space(&self) -> RCHandle<SkColorSpace>

Returns a smart pointer to ColorSpace, the range of colors, associated with Image. The smart pointer tracks the number of objects sharing this ColorSpace reference so the memory is released when the owners destruct.

The returned ColorSpace is immutable.

ColorSpace returned was passed to an Image constructor, or was parsed from encoded data. ColorSpace returned may be ignored when Image is drawn, depending on the capabilities of the crate::Surface receiving the drawing.

Returns: ColorSpace in Image, or None, wrapped in a smart pointer

example: https://fiddle.skia.org/c/@Image_refColorSpace

pub fn is_alpha_only(&self) -> bool

Returns true if Image pixels represent transparency only. If true, each pixel is packed in 8 bits as defined by ColorType::Alpha8.

Returns: true if pixels represent a transparency mask

example: https://fiddle.skia.org/c/@Image_isAlphaOnly

pub fn is_opaque(&self) -> bool

Returns true if pixels ignore their alpha value and are treated as fully opaque.

Returns: true if AlphaType is AlphaType::Opaque

pub fn to_shader<'a>( &self, tile_modes: impl Into<Option<(SkTileMode, SkTileMode)>>, sampling: impl Into<SamplingOptions>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

Make a shader with the specified tiling and mipmap sampling.

pub fn to_raw_shader<'a>( &self, tile_modes: impl Into<Option<(SkTileMode, SkTileMode)>>, sampling: impl Into<SamplingOptions>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

to_raw_shader functions like to_shader, but for images that contain non-color data. This includes images encoding things like normals, material properties (eg, roughness), heightmaps, or any other purely mathematical data that happens to be stored in an image. These types of images are useful with some programmable shaders (see: crate::RuntimeEffect).

Raw image shaders work like regular image shaders (including filtering and tiling), with a few major differences:

• No color space transformation is ever applied (the color space of the image is ignored).
• Images with an alpha type of Unpremul are not automatically premultiplied.
• Bicubic filtering is not supported. If SamplingOptions::use_cubic is true, these factories will return None.

pub fn peek_pixels(&self) -> Option<Pixmap<'_>>

Copies Image pixel address, row bytes, and ImageInfo to pixmap, if address is available, and returns true. If pixel address is not available, return false and leave pixmap unchanged.

• pixmap storage for pixel state if pixels are readable; otherwise, ignored

Returns: true if Image has direct access to pixels

example: https://fiddle.skia.org/c/@Image_peekPixels

pub fn is_texture_backed(&self) -> bool

Returns true if the contents of Image was created on or uploaded to GPU memory, and is available as a GPU texture.

Returns: true if Image is a GPU texture

example: https://fiddle.skia.org/c/@Image_isTextureBacked

pub fn texture_size(&self) -> usize

Returns an approximation of the amount of texture memory used by the image. Returns zero if the image is not texture backed or if the texture has an external format.

pub fn is_valid(&self, context: &mut RCHandle<GrRecordingContext>) -> bool

Returns true if Image can be drawn on either raster surface or GPU surface. If context is None, tests if Image draws on raster surface; otherwise, tests if Image draws on GPU surface associated with context.

Image backed by GPU texture may become invalid if associated context is invalid. lazy image may be invalid and may not draw to raster surface or GPU surface or both.

• context GPU context

Returns: true if Image can be drawn

example: https://fiddle.skia.org/c/@Image_isValid

pub fn make_scaled( &self, info: &Handle<SkImageInfo>, scaling: impl Into<SamplingOptions>, ) -> Option<RCHandle<SkImage>>

Create a new image by copying this image and scaling to fit the ImageInfo’s dimensions and converting the pixels into the ImageInfo’s crate::ColorInfo.

This is done retaining the domain (backend) of the image (e.g. gpu, raster).

Returns None if the requested crate::ColorInfo is not supported, its dimensions are out of range.

pub fn flush<'a>( &self, context: &mut RCHandle<GrDirectContext>, flush_info: impl Into<Option<&'a FlushInfo>>, ) -> GrSemaphoresSubmitted

👎Deprecated since 0.63.0: use gpu::DirectContext::flush()

See Self::flush_with_info()

pub fn flush_with_info( &self, context: &mut RCHandle<GrDirectContext>, flush_info: &FlushInfo, ) -> GrSemaphoresSubmitted

👎Deprecated since 0.46.0: use gpu::DirectContext::flush()

Flushes any pending uses of texture-backed images in the GPU backend. If the image is not texture-backed (including promise texture images) or if the gpu::DirectContext does not have the same context ID as the context backing the image then this is a no-op.

If the image was not used in any non-culled draws in the current queue of work for the passed gpu::DirectContext then this is a no-op unless the gpu::FlushInfo contains semaphores or a finish proc. Those are respected even when the image has not been used.

• context the context on which to flush pending usages of the image.
• info flush options

pub fn flush_and_submit(&self, context: &mut RCHandle<GrDirectContext>)

👎Deprecated since 0.63.0: use gpu::DirectContext::flush_and_submit()

Version of flush() that uses a default gpu::FlushInfo. Also submits the flushed work to the GPU.

pub fn backend_texture( &self, flush_pending_gr_context_io: bool, ) -> Option<(RefHandle<GrBackendTexture>, GrSurfaceOrigin)>

👎Deprecated since 0.63.0: use gpu::images::get_backend_texture_from_image()

Retrieves the back-end texture. If Image has no back-end texture, Noneis returned.

If flush_pending_gr_context_io is true, completes deferred I/O operations.

If origin in not None, copies location of content drawn into Image.

• flush_pending_gr_context_io flag to flush outstanding requests

Returns: back-end API texture handle; invalid on failure

pub fn read_pixels_with_context<'a, P>( &self, context: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, dst_info: &Handle<SkImageInfo>, pixels: &mut [P], dst_row_bytes: usize, src: impl Into<IPoint>, caching_hint: SkImage_CachingHint, ) -> bool

Copies crate::Rect of pixels from Image to dst_pixels. Copy starts at offset (src_x, src_y), and does not exceed Image (width(), height()).

Graphite has deprecated this API in favor of the equivalent asynchronous API on skgpu::graphite::Context (with an optional explicit synchronization).

dst_info specifies width, height, ColorType, AlphaType, and ColorSpace of destination. dst_row_bytes specifies the gap from one destination row to the next. Returns true if pixels are copied. Returns false if:

• dst_info.addr() equals None
• dst_row_bytes is less than dst_info.min_row_bytes()
• crate::PixelRef is None

Pixels are copied only if pixel conversion is possible. If Image ColorType is ColorType::Gray8, or ColorType::Alpha8; dst_info.color_type() must match. If Image ColorType is ColorType::Gray8, dst_info.color_space() must match. If Image AlphaType is AlphaType::Opaque, dst_info.alpha_type() must match. If Image ColorSpace is None, dst_info.color_space() must match. Returns false if pixel conversion is not possible.

src_x and src_y may be negative to copy only top or left of source. Returns false if width() or height() is zero or negative. Returns false if abs(src_x) >= Image width(), or if abs(src_y) >= Image height().

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

• context the gpu::DirectContext in play, if it exists
• dst_info destination width, height, ColorType, AlphaType, ColorSpace
• dst_pixels destination pixel storage
• dst_row_bytes destination row length
• src_x column index whose absolute value is less than width()
• src_y row index whose absolute value is less than height()
• caching_hint whether the pixels should be cached locally

Returns: true if pixels are copied to dst_pixels

pub fn read_pixels_to_pixmap_with_context<'a>( &self, context: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, dst: &Pixmap<'_>, src: impl Into<IPoint>, caching_hint: SkImage_CachingHint, ) -> bool

Copies a crate::Rect of pixels from Image to dst. Copy starts at (src_x, src_y), and does not exceed Image (width(), height()).

Graphite has deprecated this API in favor of the equivalent asynchronous API on skgpu::graphite::Context (with an optional explicit synchronization).

dst specifies width, height, ColorType, AlphaType, ColorSpace, pixel storage, and row bytes of destination. dst.row_bytes() specifics the gap from one destination row to the next. Returns true if pixels are copied. Returns false if:

• dst pixel storage equals None
• dst.row_bytes is less than ImageInfo::min_row_bytes
• crate::PixelRef is None

Pixels are copied only if pixel conversion is possible. If Image ColorType is ColorType::Gray8, or ColorType::Alpha8; dst.color_type() must match. If Image ColorType is ColorType::Gray8, dst.color_space() must match. If Image AlphaType is AlphaType::Opaque, dst.alpha_type() must match. If Image ColorSpace is None, dst.color_space() must match. Returns false if pixel conversion is not possible.

src_x and src_y may be negative to copy only top or left of source. Returns false if width() or height() is zero or negative. Returns false if abs(src_x) >= Image width(), or if abs(src_y) >= Image height().

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

• context the gpu::DirectContext in play, if it exists
• dst destination Pixmap:ImageInfo, pixels, row bytes
• src_x column index whose absolute value is less than width()
• src_y row index whose absolute value is less than height()
• caching_hint whether the pixels should be cached locally_z

Returns: true if pixels are copied to dst

pub fn read_pixels<P>( &self, dst_info: &Handle<SkImageInfo>, pixels: &mut [P], dst_row_bytes: usize, src: impl Into<IPoint>, caching_hint: SkImage_CachingHint, ) -> bool

See Self::read_pixels_with_context()

pub unsafe fn read_pixels_to_pixmap( &self, dst: &Pixmap<'_>, src: impl Into<IPoint>, caching_hint: SkImage_CachingHint, ) -> bool

See Self::read_pixels_to_pixmap_with_context()

pub fn scale_pixels( &self, dst: &Pixmap<'_>, sampling: impl Into<SamplingOptions>, caching_hint: impl Into<Option<SkImage_CachingHint>>, ) -> bool

Copies Image to dst, scaling pixels to fit dst.width() and dst.height(), and converting pixels to match dst.color_type() and dst.alpha_type(). Returns true if pixels are copied. Returns false if dst.addr() is None, or dst.row_bytes() is less than dst ImageInfo::min_row_bytes.

Pixels are copied only if pixel conversion is possible. If Image ColorType is ColorType::Gray8, or ColorType::Alpha8; dst.color_type() must match. If Image ColorType is ColorType::Gray8, dst.color_space() must match. If Image AlphaType is AlphaType::Opaque, dst.alpha_type() must match. If Image ColorSpace is None, dst.color_space() must match. Returns false if pixel conversion is not possible.

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

• dst destination Pixmap:ImageInfo, pixels, row bytes

Returns: true if pixels are scaled to fit dst

pub fn encode_to_data_with_context( &self, context: impl Into<Option<RCHandle<GrDirectContext>>>, image_format: SkEncodedImageFormat, quality: impl Into<Option<u32>>, ) -> Option<RCHandle<SkData>>

👎Deprecated since 0.63.0: Use encode

Encodes Image pixels, returning result as Data.

Returns None if encoding fails, or if encoded_image_format is not supported.

Image encoding in a format requires both building with one or more of: SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP; and platform support for the encoded format.

If SK_BUILD_FOR_MAC or SK_BUILD_FOR_IOS is defined, encoded_image_format can additionally be one of: EncodedImageFormat::ICO, EncodedImageFormat::BMP, EncodedImageFormat::GIF.

quality is a platform and format specific metric trading off size and encoding error. When used, quality equaling 100 encodes with the least error. quality may be ignored by the encoder.

• context - the gpu::DirectContext in play, if it exists; can be None
• encoded_image_format - one of: EncodedImageFormat::JPEG, EncodedImageFormat::PNG, EncodedImageFormat::WEBP
• quality - encoder specific metric with 100 equaling best

Returns: encoded Image, or None

example: https://fiddle.skia.org/c/@Image_encodeToData

pub fn encode_to_data( &self, image_format: SkEncodedImageFormat, ) -> Option<RCHandle<SkData>>

👎Deprecated since 0.63.0: Support for encoding GPU backed images without a context was removed, use encode_to_data_with_context instead

See Self::encode_to_data_with_quality

pub fn encode_to_data_with_quality( &self, image_format: SkEncodedImageFormat, quality: u32, ) -> Option<RCHandle<SkData>>

👎Deprecated since 0.63.0: Support for encoding GPU backed images without a context was removed, use encode_to_data_with_context instead

Encodes Image pixels, returning result as Data.

Returns None if encoding fails, or if encoded_image_format is not supported.

Image encoding in a format requires both building with one or more of: SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP; and platform support for the encoded format.

If SK_BUILD_FOR_MAC or SK_BUILD_FOR_IOS is defined, encoded_image_format can additionally be one of: EncodedImageFormat::ICO, EncodedImageFormat::BMP, EncodedImageFormat::GIF.

quality is a platform and format specific metric trading off size and encoding error. When used, quality equaling 100 encodes with the least error. quality may be ignored by the encoder.

• encoded_image_format one of: EncodedImageFormat::JPEG, EncodedImageFormat::PNG, EncodedImageFormat::WEBP
• quality encoder specific metric with 100 equaling best

Returns: encoded Image, or None

example: https://fiddle.skia.org/c/@Image_encodeToData

pub fn encoded_data(&self) -> Option<RCHandle<SkData>>

Returns encoded Image pixels as Data, if Image was created from supported encoded stream format. Platform support for formats vary and may require building with one or more of: SK_ENCODE_JPEG, SK_ENCODE_PNG, SK_ENCODE_WEBP.

Returns None if Image contents are not encoded.

Returns: encoded Image, or None

example: https://fiddle.skia.org/c/@Image_refEncodedData

pub fn new_subset(&self, rect: impl AsRef<IRect>) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.64.0: use make_subset()

See Self::new_subset_with_context

pub fn new_subset_with_context<'a>( &self, rect: impl AsRef<IRect>, direct: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.64.0: use make_subset()

Returns subset of this image.

Returns None if any of the following are true:

• Subset is empty
• Subset is not contained inside the image’s bounds
• Pixels in the image could not be read or copied

If this image is texture-backed, the context parameter is required and must match the context of the source image. If the context parameter is provided, and the image is raster-backed, the subset will be converted to texture-backed.

• subset bounds of returned Image
• context the gpu::DirectContext in play, if it exists

Returns: the subsetted image, or None

example: https://fiddle.skia.org/c/@Image_makeSubset

pub fn make_subset<'a>( &self, direct: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, subset: impl AsRef<IRect>, ) -> Option<RCHandle<SkImage>>

Returns subset of this image.

Returns None if any of the following are true: - Subset is empty - Subset is not contained inside the image’s bounds - Pixels in the source image could not be read or copied - This image is texture-backed and the provided context is null or does not match the source image’s context.

If the source image was texture-backed, the resulting image will be texture-backed also. Otherwise, the returned image will be raster-backed.

• direct - the gpu::DirectContext of the source image (None is ok if the source image is not texture-backed).
• subset - bounds of returned Image Returns: the subsetted image, or None

example: https://fiddle.skia.org/c/@Image_makeSubset

pub fn has_mipmaps(&self) -> bool

Returns true if the image has mipmap levels.

pub fn with_default_mipmaps(&self) -> Option<RCHandle<SkImage>>

Returns an image with the same “base” pixels as the this image, but with mipmap levels automatically generated and attached.

pub fn new_texture_image( &self, context: &mut RCHandle<GrDirectContext>, mipmapped: skgpu_Mipmapped, ) -> Option<RCHandle<SkImage>>

See Self::new_texture_image_budgeted

pub fn new_texture_image_budgeted( &self, direct_context: &mut RCHandle<GrDirectContext>, mipmapped: skgpu_Mipmapped, budgeted: Budgeted, ) -> Option<RCHandle<SkImage>>

Returns Image backed by GPU texture associated with context. Returned Image is compatible with crate::Surface created with dst_color_space. The returned Image respects mipmapped setting; if mipmapped equals gpu::Mipmapped::Yes, the backing texture allocates mip map levels.

The mipmapped parameter is effectively treated as No if MIP maps are not supported by the GPU.

Returns original Image if the image is already texture-backed, the context matches, and mipmapped is compatible with the backing GPU texture. crate::Budgeted is ignored in this case.

Returns None if context is None, or if Image was created with another gpu::DirectContext.

• direct_context the gpu::DirectContext in play, if it exists
• mipmapped whether created Image texture must allocate mip map levels
• budgeted whether to count a newly created texture for the returned image counts against the context’s budget.

Returns: created Image, or None

pub fn to_non_texture_image(&self) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.64.0: use make_non_texture_image()

Returns raster image or lazy image. Copies Image backed by GPU texture into CPU memory if needed. Returns original Image if decoded in raster bitmap, or if encoded in a stream.

Returns None if backed by GPU texture and copy fails.

Returns: raster image, lazy image, or None

example: https://fiddle.skia.org/c/@Image_makeNonTextureImage

pub fn make_non_texture_image<'a>( &self, context: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, ) -> Option<RCHandle<SkImage>>

Returns raster image or lazy image. Copies Image backed by GPU texture into CPU memory if needed. Returns original Image if decoded in raster bitmap, or if encoded in a stream.

Returns None if backed by GPU texture and copy fails.

Returns: raster image, lazy image, or None

example: https://fiddle.skia.org/c/@Image_makeNonTextureImage

pub fn to_raster_image( &self, caching_hint: impl Into<Option<SkImage_CachingHint>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.64.0: use make_raster_image()

Returns raster image. Copies Image backed by GPU texture into CPU memory, or decodes Image from lazy image. Returns original Image if decoded in raster bitmap.

Returns None if copy, decode, or pixel read fails.

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

Returns: raster image, or None

example: https://fiddle.skia.org/c/@Image_makeRasterImage

pub fn make_raster_image<'a>( &self, context: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, caching_hint: impl Into<Option<SkImage_CachingHint>>, ) -> Option<RCHandle<SkImage>>

Returns raster image. Copies Image backed by GPU texture into CPU memory, or decodes Image from lazy image. Returns original Image if decoded in raster bitmap.

Returns None if copy, decode, or pixel read fails.

If caching_hint is CachingHint::Allow, pixels may be retained locally. If caching_hint is CachingHint::Disallow, pixels are not added to the local cache.

Returns: raster image, or None

example: https://fiddle.skia.org/c/@Image_makeRasterImage

pub fn new_with_filter( &self, _context: Option<&mut RCHandle<GrRecordingContext>>, filter: &RCHandle<SkImageFilter>, clip_bounds: impl Into<IRect>, subset: impl Into<IRect>, ) -> Option<(RCHandle<SkImage>, IRect, IPoint)>

👎Deprecated since 0.67.0: use images::make_with_filter()

Creates filtered Image. filter processes original Image, potentially changing color, position, and size. subset is the bounds of original Image processed by filter. clip_bounds is the expected bounds of the filtered Image. out_subset is required storage for the actual bounds of the filtered Image. offset is required storage for translation of returned Image.

Returns None if Image could not be created or if the recording context provided doesn’t match the GPU context in which the image was created. If None is returned, out_subset and offset are undefined.

Useful for animation of ImageFilter that varies size from frame to frame. Returned Image is created larger than required by filter so that GPU texture can be reused with different sized effects. out_subset describes the valid bounds of GPU texture returned. offset translates the returned Image to keep subsequent animation frames aligned with respect to each other.

• context the gpu::RecordingContext in play - if it exists
• filter how Image is sampled when transformed
• subset bounds of Image processed by filter
• clip_bounds expected bounds of filtered Image
• out_subset storage for returned Image bounds
• offset storage for returned Image translation

Returns: filtered Image, or None

pub fn is_lazy_generated(&self) -> bool

Returns true if Image is backed by an image-generator or other service that creates and caches its pixels or texture on-demand.

Returns: true if Image is created as needed

example: https://fiddle.skia.org/c/@Image_isLazyGenerated_a example: https://fiddle.skia.org/c/@Image_isLazyGenerated_b

pub fn new_color_space( &self, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.64.0: use make_color_space()

See Self::new_color_space_with_context

pub fn new_color_space_with_context<'a>( &self, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, direct: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, ) -> Option<RCHandle<SkImage>>

👎Deprecated since 0.64.0: use make_color_space()

Creates Image in target ColorSpace. Returns None if Image could not be created.

Returns original Image if it is in target ColorSpace. Otherwise, converts pixels from Image ColorSpace to target ColorSpace. If Image color_space() returns None, Image ColorSpace is assumed to be s_rgb.

If this image is texture-backed, the context parameter is required and must match the context of the source image.

• target ColorSpace describing color range of returned Image
• direct The gpu::DirectContext in play, if it exists

Returns: created Image in target ColorSpace

example: https://fiddle.skia.org/c/@Image_makeColorSpace

pub fn make_color_space<'a>( &self, direct: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, ) -> Option<RCHandle<SkImage>>

Creates Image in target ColorSpace. Returns None if Image could not be created.

Returns original Image if it is in target ColorSpace. Otherwise, converts pixels from Image ColorSpace to target ColorSpace. If Image color_space() returns None, Image ColorSpace is assumed to be s_rgb.

If this image is texture-backed, the context parameter is required and must match the context of the source image.

• direct The gpu::DirectContext in play, if it exists
• target ColorSpace describing color range of returned Image

Returns: created Image in target ColorSpace

example: https://fiddle.skia.org/c/@Image_makeColorSpace

pub fn reinterpret_color_space( &self, new_color_space: impl Into<RCHandle<SkColorSpace>>, ) -> Option<RCHandle<SkImage>>

Creates a new Image identical to this one, but with a different ColorSpace. This does not convert the underlying pixel data, so the resulting image will draw differently.

impl RCHandle<SkImageFilter>

pub fn filter_bounds<'a>( &self, src: impl AsRef<IRect>, ctm: &Matrix, map_direction: SkImageFilter_MapDirection, input_rect: impl Into<Option<&'a IRect>>, ) -> IRect

pub fn color_filter_node(&self) -> Option<RCHandle<SkColorFilter>>

pub fn to_a_color_filter(&self) -> Option<RCHandle<SkColorFilter>>

pub fn count_inputs(&self) -> usize

pub fn input(&self, i: usize) -> Option<RCHandle<SkImageFilter>>

👎Deprecated: use get_input()

pub fn get_input(&self, i: usize) -> Option<RCHandle<SkImageFilter>>

pub fn inputs( &self, ) -> impl Iterator<Item = Option<RCHandle<SkImageFilter>>> + use<'_>

pub fn compute_fast_bounds(&self, bounds: impl AsRef<Rect>) -> Rect

pub fn can_compute_fast_bounds(&self) -> bool

pub fn with_local_matrix( &self, matrix: &Matrix, ) -> Option<RCHandle<SkImageFilter>>

impl RCHandle<SkMaskFilter>

pub fn blur( style: SkBlurStyle, sigma: f32, respect_ctm: impl Into<Option<bool>>, ) -> Option<RCHandle<SkMaskFilter>>

Create a blur mask filter.

• style The BlurStyle to use
• sigma Standard deviation of the Gaussian blur to apply. Must be > 0.
• respect_ctm if true the blur’s sigma is modified by the ctm.

Returns the new blur mask filter

impl RCHandle<SkPathEffect>

pub fn sum( first: impl Into<RCHandle<SkPathEffect>>, second: impl Into<RCHandle<SkPathEffect>>, ) -> RCHandle<SkPathEffect>

pub fn compose( first: impl Into<RCHandle<SkPathEffect>>, second: impl Into<RCHandle<SkPathEffect>>, ) -> RCHandle<SkPathEffect>

pub fn filter_path( &self, src: &Handle<SkPath>, stroke_rec: &Handle<SkStrokeRec>, cull_rect: impl AsRef<Rect>, ) -> Option<(Handle<SkPath>, Handle<SkStrokeRec>)>

pub fn filter_path_inplace( &self, dst: &mut Handle<SkPath>, src: &Handle<SkPath>, stroke_rec: &mut Handle<SkStrokeRec>, cull_rect: impl AsRef<Rect>, ) -> bool

pub fn filter_path_inplace_with_matrix( &self, dst: &mut Handle<SkPath>, src: &Handle<SkPath>, stroke_rec: &mut Handle<SkStrokeRec>, cull_rect: impl AsRef<Rect>, ctm: &Matrix, ) -> bool

pub fn needs_ctm(&self) -> bool

impl RCHandle<SkPicture>

pub fn from_data(data: &RCHandle<SkData>) -> Option<RCHandle<SkPicture>>

pub fn from_bytes(bytes: &[u8]) -> Option<RCHandle<SkPicture>>

pub fn playback(&self, canvas: &Canvas)

pub fn cull_rect(&self) -> Rect

pub fn unique_id(&self) -> u32

pub fn serialize(&self) -> RCHandle<SkData>

pub fn new_placeholder(cull: impl AsRef<Rect>) -> RCHandle<SkPicture>

pub fn approximate_op_count(&self) -> usize

pub fn approximate_op_count_nested( &self, nested: impl Into<Option<bool>>, ) -> usize

pub fn approximate_bytes_used(&self) -> usize

pub fn to_shader<'a, 'b>( &self, tm: impl Into<Option<(SkTileMode, SkTileMode)>>, mode: SkFilterMode, local_matrix: impl Into<Option<&'a Matrix>>, tile_rect: impl Into<Option<&'b Rect>>, ) -> RCHandle<SkShader>

impl RCHandle<SkPixelRef>

pub fn dimensions(&self) -> ISize

pub fn width(&self) -> i32

pub fn height(&self) -> i32

pub unsafe fn pixels(&self) -> *mut c_void

pub fn row_bytes(&self) -> usize

pub fn generation_id(&self) -> u32

pub fn notify_pixels_changed(&mut self)

pub fn is_immutable(&self) -> bool

pub fn set_immutable(&mut self)

pub fn notify_added_to_cache(&mut self)

impl RCHandle<SkShader>

Shaders specify the source color(s) for what is being drawn. If a paint has no shader, then the paint’s color is used. If the paint has a shader, then the shader’s color(s) are use instead, but they are modulated by the paint’s alpha. This makes it easy to create a shader once (e.g. bitmap tiling or gradient) and then change its transparency w/o having to modify the original shader… only the paint’s alpha needs to be modified.

pub fn is_opaque(&self) -> bool

Returns true if the shader is guaranteed to produce only opaque colors, subject to the crate::Paint using the shader to apply an opaque alpha value. Subclasses should override this to allow some optimizations.

pub fn image( &self, ) -> Option<(RCHandle<SkImage>, Matrix, (SkTileMode, SkTileMode))>

Returns iff this shader is backed by a single Image. If not, returns None.

pub fn is_a_image(&self) -> bool

pub fn with_local_matrix(&self, matrix: &Matrix) -> RCHandle<SkShader>

Return a shader that will apply the specified local_matrix to this shader. The specified matrix will be applied before any matrix associated with this shader.

pub fn with_color_filter( &self, color_filter: impl Into<RCHandle<SkColorFilter>>, ) -> RCHandle<SkShader>

Create a new shader that produces the same colors as invoking this shader and then applying the color filter.

pub fn with_working_color_space( &self, color_space: impl Into<RCHandle<SkColorSpace>>, ) -> RCHandle<SkShader>

Return a shader that will compute this shader in a specific color space. By default, all shaders operate in the destination (surface) color space. The results of a shader are still always converted to the destination - this API has no impact on simple shaders or images. Primarily, it impacts shaders that perform mathematical operations, like Blend shaders, or runtime shaders.

impl RCHandle<SkSurface>

pub fn new_raster_direct<'pixels>( image_info: &Handle<SkImageInfo>, pixels: &'pixels mut [u8], row_bytes: impl Into<Option<usize>>, surface_props: Option<&SurfaceProps>, ) -> Option<Borrows<'pixels, RCHandle<SkSurface>>>

👎Deprecated since 0.64.0: use surfaces::wrap_pixels()

Allocates raster Surface. Canvas returned by Surface draws directly into pixels.

Surface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains crate::ColorType and crate::AlphaType supported by raster surface; pixels is not None; row_bytes is large enough to contain info width pixels of crate::ColorType.

Pixel buffer size should be info height times computed row_bytes. Pixels are not initialized. To access pixels after drawing, Self::peek_pixels() or Self::read_pixels().

• image_info - width, height, crate::ColorType, crate::AlphaType, crate::ColorSpace, of raster surface; width and height must be greater than zero
• pixels - pointer to destination pixels buffer
• row_bytes - interval from one Surface row to the next
• surface_props - LCD striping orientation and setting for device independent fonts; may be None

Returns: Surface if all parameters are valid; otherwise, None

pub fn new_raster( image_info: &Handle<SkImageInfo>, row_bytes: impl Into<Option<usize>>, surface_props: Option<&SurfaceProps>, ) -> Option<RCHandle<SkSurface>>

👎Deprecated since 0.64.0: use surfaces::raster()

Allocates raster Surface. Canvas returned by Surface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is image_info.height() times row_bytes, or times image_info.min_row_bytes() if row_bytes is zero. Pixel memory is deleted when Surface is deleted.

Surface is returned if all parameters are valid. Valid parameters include: info dimensions are greater than zero; info contains crate::ColorType and crate::AlphaType supported by raster surface; row_bytes is large enough to contain info width pixels of crate::ColorType, or is zero.

If row_bytes is zero, a suitable value will be chosen internally.

• image_info - width, height, crate::ColorType, crate::AlphaType, crate::ColorSpace, of raster surface; width and height must be greater than zero
• row_bytes - interval from one Surface row to the next; may be zero
• surface_props - LCD striping orientation and setting for device independent fonts; may be None

Returns: Surface if all parameters are valid; otherwise, None

pub fn new_raster_n32_premul( size: impl Into<ISize>, ) -> Option<RCHandle<SkSurface>>

👎Deprecated since 0.64.0: use surfaces::raster_n32_premul()

Allocates raster Surface. Canvas returned by Surface draws directly into pixels. Allocates and zeroes pixel memory. Pixel memory size is height times width times four. Pixel memory is deleted when Surface is deleted.

Internally, sets ImageInfo to width, height, native color type, and crate::AlphaType::Premul.

Surface is returned if width and height are greater than zero.

Use to create Surface that matches crate::PMColor, the native pixel arrangement on the platform. Surface drawn to output device skips converting its pixel format.

• width - pixel column count; must be greater than zero
• height - pixel row count; must be greater than zero
• surface_props - LCD striping orientation and setting for device independent fonts; may be None

Returns: Surface if all parameters are valid; otherwise, None

impl RCHandle<SkSurface>

pub fn from_backend_texture( context: &mut RCHandle<GrRecordingContext>, backend_texture: &RefHandle<GrBackendTexture>, origin: GrSurfaceOrigin, sample_cnt: impl Into<Option<usize>>, color_type: ColorType, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, surface_props: Option<&SurfaceProps>, ) -> Option<RCHandle<SkSurface>>

👎Deprecated since 0.64.0: use gpu::surfaces::wrap_backend_texture()

Wraps a GPU-backed texture into Surface. Caller must ensure the texture is valid for the lifetime of returned Surface. If sample_cnt greater than zero, creates an intermediate MSAA Surface which is used for drawing backend_texture.

Surface is returned if all parameters are valid. backend_texture is valid if its pixel configuration agrees with color_space and context; for instance, if backend_texture has an sRGB configuration, then context must support sRGB, and color_space must be present. Further, backend_texture width and height must not exceed context capabilities, and the context must be able to support back-end textures.

• context - GPU context
• backend_texture - texture residing on GPU
• sample_cnt - samples per pixel, or 0 to disable full scene anti-aliasing
• color_space - range of colors; may be None
• surface_props - LCD striping orientation and setting for device independent fonts; may be None

Returns: Surface if all parameters are valid; otherwise, None

pub fn from_backend_render_target( context: &mut RCHandle<GrRecordingContext>, backend_render_target: &Handle<GrBackendRenderTarget>, origin: GrSurfaceOrigin, color_type: ColorType, color_space: impl Into<Option<RCHandle<SkColorSpace>>>, surface_props: Option<&SurfaceProps>, ) -> Option<RCHandle<SkSurface>>

👎Deprecated since 0.64.0: use gpu::surfaces::wrap_backend_render_target()

Wraps a GPU-backed buffer into Surface. Caller must ensure backend_render_target is valid for the lifetime of returned Surface.

Surface is returned if all parameters are valid. backend_render_target is valid if its pixel configuration agrees with color_space and context; for instance, if backend_render_target has an sRGB configuration, then context must support sRGB, and color_space must be present. Further, backend_render_target width and height must not exceed context capabilities, and the context must be able to support back-end render targets.

• context - GPU context
• backend_render_target - GPU intermediate memory buffer
• color_space - range of colors
• surface_props - LCD striping orientation and setting for device independent fonts; may be None

Returns: Surface if all parameters are valid; otherwise, None

pub fn new_render_target( context: &mut RCHandle<GrRecordingContext>, budgeted: Budgeted, image_info: &Handle<SkImageInfo>, sample_count: impl Into<Option<usize>>, surface_origin: impl Into<Option<GrSurfaceOrigin>>, surface_props: Option<&SurfaceProps>, should_create_with_mips: impl Into<Option<bool>>, ) -> Option<RCHandle<SkSurface>>

👎Deprecated since 0.64.0: use gpu::surfaces::render_target()

Returns Surface on GPU indicated by context. Allocates memory for pixels, based on the width, height, and crate::ColorType in ImageInfo. budgeted selects whether allocation for pixels is tracked by context. image_info describes the pixel format in crate::ColorType, and transparency in crate::AlphaType, and color matching in crate::ColorSpace.

sample_count requests the number of samples per pixel. Pass zero to disable multi-sample anti-aliasing. The request is rounded up to the next supported count, or rounded down if it is larger than the maximum supported count.

surface_origin pins either the top-left or the bottom-left corner to the origin.

should_create_with_mips hints that Image returned by Image::image_snapshot is mip map.

• context - GPU context
• image_info - width, height, crate::ColorType, crate::AlphaType, crate::ColorSpace; width, or height, or both, may be zero
• sample_count - samples per pixel, or 0 to disable full scene anti-aliasing
• surface_props - LCD striping orientation and setting for device independent fonts; may be None
• should_create_with_mips - hint that Surface will host mip map images

Returns: Surface if all parameters are valid; otherwise, None

impl RCHandle<SkSurface>

pub fn new_null(size: impl Into<ISize>) -> Option<RCHandle<SkSurface>>

👎Deprecated since 0.64.0: use surfaces::null()

Returns Surface without backing pixels. Drawing to Canvas returned from Surface has no effect. Calling Self::image_snapshot() on returned Surface returns None.

• width - one or greater
• height - one or greater

Returns: Surface if width and height are positive; otherwise, None

example: https://fiddle.skia.org/c/@Surface_MakeNull

pub fn width(&self) -> i32

Returns pixel count in each row; may be zero or greater.

Returns: number of pixel columns

pub fn height(&self) -> i32

Returns pixel row count; may be zero or greater.

Returns: number of pixel rows

pub fn image_info(&mut self) -> Handle<SkImageInfo>

Returns an ImageInfo describing the surface.

pub fn generation_id(&mut self) -> u32

Returns unique value identifying the content of Surface. Returned value changes each time the content changes. Content is changed by drawing, or by calling Self::notify_content_will_change().

Returns: unique content identifier

example: https://fiddle.skia.org/c/@Surface_notifyContentWillChange

pub fn notify_content_will_change( &mut self, mode: SkSurface_ContentChangeMode, ) -> &mut RCHandle<SkSurface>

Notifies that Surface contents will be changed by code outside of Skia. Subsequent calls to Self::generation_id() return a different value.

example: https://fiddle.skia.org/c/@Surface_notifyContentWillChange

impl RCHandle<SkSurface>

pub fn recording_context(&self) -> Option<RCHandle<GrRecordingContext>>

Returns the recording context being used by the Surface.

Returns: the recording context, if available; None otherwise

pub fn direct_context(&self) -> Option<RCHandle<GrDirectContext>>

rust-skia helper, not in Skia

pub fn get_backend_texture( &mut self, handle_access: SkSurface_BackendHandleAccess, ) -> Option<RefHandle<GrBackendTexture>>

👎Deprecated since 0.64.0: use gpu::surfaces::get_backend_texture()

Retrieves the back-end texture. If Surface has no back-end texture, None is returned.

The returned gpu::BackendTexture should be discarded if the Surface is drawn to or deleted.

Returns: GPU texture reference; None on failure

pub fn get_backend_render_target( &mut self, handle_access: SkSurface_BackendHandleAccess, ) -> Option<Handle<GrBackendRenderTarget>>

👎Deprecated since 0.64.0: use gpu::surfaces::get_backend_render_target()

Retrieves the back-end render target. If Surface has no back-end render target, None is returned.

The returned gpu::BackendRenderTarget should be discarded if the Surface is drawn to or deleted.

Returns: GPU render target reference; None on failure

pub fn replace_backend_texture( &mut self, backend_texture: &RefHandle<GrBackendTexture>, origin: GrSurfaceOrigin, ) -> bool

If the surface was made via Self::from_backend_texture then it’s backing texture may be substituted with a different texture. The contents of the previous backing texture are copied into the new texture. Canvas state is preserved. The original sample count is used. The gpu::BackendFormat and dimensions of replacement texture must match that of the original.

• backend_texture - the new backing texture for the surface

pub fn replace_backend_texture_with_mode( &mut self, backend_texture: &RefHandle<GrBackendTexture>, origin: GrSurfaceOrigin, mode: impl Into<Option<SkSurface_ContentChangeMode>>, ) -> bool

If the surface was made via Self::from_backend_texture() then it’s backing texture may be substituted with a different texture. The contents of the previous backing texture are copied into the new texture. Canvas state is preserved. The original sample count is used. The gpu::BackendFormat and dimensions of replacement texture must match that of the original.

• backend_texture - the new backing texture for the surface
• mode - Retain or discard current Content

impl RCHandle<SkSurface>

pub fn canvas(&mut self) -> &Canvas

Returns Canvas that draws into Surface. Subsequent calls return the same Canvas. Canvas returned is managed and owned by Surface, and is deleted when Surface is deleted.

Returns: drawing Canvas for Surface

example: https://fiddle.skia.org/c/@Surface_getCanvas

pub fn new_surface( &mut self, image_info: &Handle<SkImageInfo>, ) -> Option<RCHandle<SkSurface>>

Returns a compatible Surface, or None. Returned Surface contains the same raster, GPU, or null properties as the original. Returned Surface does not share the same pixels.

Returns None if image_info width or height are zero, or if image_info is incompatible with Surface.

• image_info - width, height, crate::ColorType, crate::AlphaType, crate::ColorSpace, of Surface; width and height must be greater than zero

Returns: compatible Surface or None

example: https://fiddle.skia.org/c/@Surface_makeSurface

pub fn new_surface_with_dimensions( &mut self, dim: impl Into<ISize>, ) -> Option<RCHandle<SkSurface>>

Calls Self::new_surface() with the same ImageInfo as this surface, but with the specified width and height.

pub fn image_snapshot(&mut self) -> RCHandle<SkImage>

Returns Image capturing Surface contents. Subsequent drawing to Surface contents are not captured. Image allocation is accounted for if Surface was created with gpu::Budgeted::Yes.

Returns: Image initialized with Surface contents

example: https://fiddle.skia.org/c/@Surface_makeImageSnapshot

pub fn make_temporary_image(&mut self) -> Option<RCHandle<SkImage>>

Returns an Image capturing the current Surface contents. However, the contents of the Image are only valid as long as no other writes to the Surface occur. If writes to the original Surface happen then contents of the Image are undefined. However, continued use of the Image should not cause crashes or similar fatal behavior.

This API is useful for cases where the client either immediately destroys the Surface after the Image is created or knows they will destroy the Image before writing to the Surface again.

This API can be more performant than Self::image_snapshot() as it never does an internal copy of the data assuming the user frees either the Image or Surface as described above.

pub fn image_snapshot_with_bounds( &mut self, bounds: impl AsRef<IRect>, ) -> Option<RCHandle<SkImage>>

Like the no-parameter version, this returns an image of the current surface contents. This variant takes a rectangle specifying the subset of the surface that is of interest. These bounds will be sanitized before being used.

• If bounds extends beyond the surface, it will be trimmed to just the intersection of it and the surface.
• If bounds does not intersect the surface, then this returns None.
• If bounds == the surface, then this is the same as calling the no-parameter variant.

example: https://fiddle.skia.org/c/@Surface_makeImageSnapshot_2

pub fn draw( &mut self, canvas: &Canvas, offset: impl Into<Point>, sampling: impl Into<SamplingOptions>, paint: Option<&Handle<SkPaint>>, )

Draws Surface contents to canvas, with its top-left corner at (offset.x, offset.y).

If Paint paint is not None, apply crate::ColorFilter, alpha, crate::ImageFilter, and crate::BlendMode.

• canvas - Canvas drawn into
• offset.x - horizontal offset in Canvas
• offset.y - vertical offset in Canvas
• sampling - what technique to use when sampling the surface pixels
• paint - Paint containing crate::BlendMode, crate::ColorFilter, crate::ImageFilter, and so on; or None

example: https://fiddle.skia.org/c/@Surface_draw

pub fn peek_pixels(&mut self) -> Option<Pixmap<'_>>

pub fn read_pixels_to_pixmap( &mut self, dst: &Pixmap<'_>, src: impl Into<IPoint>, ) -> bool

Copies crate::Rect of pixels to dst.

Source crate::Rect corners are (src.x, src.y) and Surface (width(), height()). Destination crate::Rect corners are (0, 0) and (dst.width(), dst.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to dst_color_type() and dst_alpha_type() if required.

Pixels are readable when Surface is raster, or backed by a Ganesh GPU backend. Graphite has deprecated this API in favor of the equivalent asynchronous API on skgpu::graphite::Context (with an optional explicit synchonization).

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if crate::ColorType and crate::AlphaType do not match. Only pixels within both source and destination rectangles are copied. dst contents outside crate::Rect intersection are unchanged.

Pass negative values for src.x or src.y to offset pixels across or down destination.

Does not copy, and returns false if:

• Source and destination rectangles do not intersect.
• Pixmap pixels could not be allocated.
• dst.row_bytes() is too small to contain one row of pixels.

• dst - storage for pixels copied from Surface
• src_x - offset into readable pixels on x-axis; may be negative
• src_y - offset into readable pixels on y-axis; may be negative

Returns: true if pixels were copied

example: https://fiddle.skia.org/c/@Surface_readPixels

pub fn read_pixels( &mut self, dst_info: &Handle<SkImageInfo>, dst_pixels: &mut [u8], dst_row_bytes: usize, src: impl Into<IPoint>, ) -> bool

Copies crate::Rect of pixels from Canvas into dst_pixels.

Source crate::Rect corners are (src.x, src.y) and Surface (width(), height()). Destination crate::Rect corners are (0, 0) and (dst_info.width(), dst_info.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to dst_info_color_type() and dst_info_alpha_type() if required.

Pixels are readable when Surface is raster, or backed by a Ganesh GPU backend. Graphite has deprecated this API in favor of the equivalent asynchronous API on skgpu::graphite::Context (with an optional explicit synchonization).

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if crate::ColorType and crate::AlphaType do not match. Only pixels within both source and destination rectangles are copied. dst_pixels contents outside crate::Rect intersection are unchanged.

Pass negative values for src.x or src.y to offset pixels across or down destination.

Does not copy, and returns false if:

• Source and destination rectangles do not intersect.
• Surface pixels could not be converted to dst_info.color_type() or dst_info.alpha_type().
• dst_row_bytes is too small to contain one row of pixels.

• dst_info - width, height, crate::ColorType, and crate::AlphaType of dst_pixels
• dst_pixels - storage for pixels; dst_info.height() times dst_row_bytes, or larger
• dst_row_bytes - size of one destination row; dst_info.width() times pixel size, or larger
• src.x - offset into readable pixels on x-axis; may be negative
• src.y - offset into readable pixels on y-axis; may be negative

Returns: true if pixels were copied

pub fn read_pixels_to_bitmap( &mut self, bitmap: &Handle<SkBitmap>, src: impl Into<IPoint>, ) -> bool

Copies crate::Rect of pixels from Surface into bitmap.

Source crate::Rect corners are (src.x, src.y) and Surface (width(), height()). Destination crate::Rect corners are (0, 0) and (bitmap.width(), bitmap.height()). Copies each readable pixel intersecting both rectangles, without scaling, converting to bitmap.color_type() and bitmap.alpha_type() if required.

Pixels are readable when Surface is raster, or backed by a Ganesh GPU backend. Graphite has deprecated this API in favor of the equivalent asynchronous API on skgpu::graphite::Context (with an optional explicit synchonization).

The destination pixel storage must be allocated by the caller.

Pixel values are converted only if crate::ColorType and crate::AlphaType do not match. Only pixels within both source and destination rectangles are copied. dst contents outside crate::Rect intersection are unchanged.

Pass negative values for src.x or src.y to offset pixels across or down destination.

Does not copy, and returns false if:

• Source and destination rectangles do not intersect.
• Surface pixels could not be converted to dst.color_type() or dst.alpha_type().
• dst pixels could not be allocated.
• dst.row_bytes() is too small to contain one row of pixels.

• dst - storage for pixels copied from Surface
• src.x - offset into readable pixels on x-axis; may be negative
• src.y - offset into readable pixels on y-axis; may be negative

Returns: true if pixels were copied

example: https://fiddle.skia.org/c/@Surface_readPixels_3

pub fn write_pixels_from_pixmap( &mut self, src: &Pixmap<'_>, dst: impl Into<IPoint>, )

Copies crate::Rect of pixels from the src Pixmap to the Surface.

Source crate::Rect corners are (0, 0) and (src.width(), src.height()). Destination crate::Rect corners are (dst.x, dst.y) and (dst.x + Surface width(), dst.y + Surface height()).

Copies each readable pixel intersecting both rectangles, without scaling, converting to Surface color_type() and Surface alpha_type() if required.

• src - storage for pixels to copy to Surface
• dst.x - x-axis position relative to Surface to begin copy; may be negative
• dst.y - y-axis position relative to Surface to begin copy; may be negative

example: https://fiddle.skia.org/c/@Surface_writePixels

pub fn write_pixels_from_bitmap( &mut self, bitmap: &Handle<SkBitmap>, dst: impl Into<IPoint>, )

Copies crate::Rect of pixels from the src Bitmap to the Surface.

Source crate::Rect corners are (0, 0) and (src.width(), src.height()). Destination crate::Rect corners are (dst.x, dst.y) and (dst.x+ Surface width(),dst.y + Surface height()).

Copies each readable pixel intersecting both rectangles, without scaling, converting to Surface color_type() and Surface alpha_type() if required.

• src - storage for pixels to copy to Surface
• dst.x - x-axis position relative to Surface to begin copy; may be negative
• dst.y - y-axis position relative to Surface to begin copy; may be negative

example: https://fiddle.skia.org/c/@Surface_writePixels_2

pub fn props(&self) -> &SurfaceProps

Returns SurfaceProps for surface.

Returns: LCD striping orientation and setting for device independent fonts

impl RCHandle<SkSurface>

pub fn resolve_msaa(&mut self)

👎Deprecated since 0.65.0: Use gpu::surfaces::resolve_msaa

If a surface is GPU texture backed, is being drawn with MSAA, and there is a resolve texture, this call will insert a resolve command into the stream of gpu commands. In order for the resolve to actually have an effect, the work still needs to be flushed and submitted to the GPU after recording the resolve command. If a resolve is not supported or the Surface has no dirty work to resolve, then this call is a no-op.

This call is most useful when the Surface is created by wrapping a single sampled gpu texture, but asking Skia to render with MSAA. If the client wants to use the wrapped texture outside of Skia, the only way to trigger a resolve is either to call this command or use Self::flush().

impl RCHandle<SkTextBlob>

pub fn new( str: impl AsRef<str>, font: &Handle<SkFont>, ) -> Option<RCHandle<SkTextBlob>>

pub fn bounds(&self) -> &Rect

pub fn unique_id(&self) -> u32

pub fn get_intercepts( &self, bounds: [f32; 2], paint: Option<&Handle<SkPaint>>, ) -> Vec<f32>

pub fn from_str( str: impl AsRef<str>, font: &Handle<SkFont>, ) -> Option<RCHandle<SkTextBlob>>

pub fn from_text( text: impl EncodedText, font: &Handle<SkFont>, ) -> Option<RCHandle<SkTextBlob>>

pub fn from_pos_text_h( text: impl EncodedText, x_pos: &[f32], const_y: f32, font: &Handle<SkFont>, ) -> Option<RCHandle<SkTextBlob>>

pub fn from_pos_text( text: impl EncodedText, pos: &[Point], font: &Handle<SkFont>, ) -> Option<RCHandle<SkTextBlob>>

pub fn from_rsxform( text: impl EncodedText, xform: &[RSXform], font: &Handle<SkFont>, ) -> Option<RCHandle<SkTextBlob>>

impl RCHandle<SkTypeface>

pub fn font_style(&self) -> FontStyle

pub fn is_bold(&self) -> bool

pub fn is_italic(&self) -> bool

pub fn is_fixed_pitch(&self) -> bool

pub fn variation_design_position(&self) -> Option<Vec<Coordinate>>

pub fn variation_design_parameters(&self) -> Option<Vec<Axis>>

pub fn unique_id(&self) -> u32

pub fn equal( face_a: impl AsRef<RCHandle<SkTypeface>>, face_b: impl AsRef<RCHandle<SkTypeface>>, ) -> bool

pub fn clone_with_arguments( &self, arguments: &FontArguments<'_, '_>, ) -> Option<RCHandle<SkTypeface>>

pub fn serialize_stream( &self, write: impl Write, behavior: SkTypeface_SerializeBehavior, )

pub fn serialize( &self, behavior: SkTypeface_SerializeBehavior, ) -> RCHandle<SkData>

pub fn make_deserialize( data: impl Read, last_resort_mgr: impl Into<Option<RCHandle<SkFontMgr>>>, ) -> Option<RCHandle<SkTypeface>>

pub fn unichars_to_glyphs(&self, uni: &[i32], glyphs: &mut [u16])

pub fn str_to_glyphs(&self, str: impl AsRef<str>, glyphs: &mut [u16]) -> usize

pub fn text_to_glyphs( &self, text: impl EncodedText, glyphs: &mut [u16], ) -> usize

pub fn unichar_to_glyph(&self, unichar: i32) -> u16

pub fn count_glyphs(&self) -> usize

pub fn count_tables(&self) -> usize

pub fn table_tags(&self) -> Option<Vec<u32>>

pub fn get_table_size(&self, tag: u32) -> Option<usize>

pub fn get_table_data(&self, tag: u32, data: &mut [u8]) -> usize

pub fn copy_table_data(&self, tag: u32) -> Option<RCHandle<SkData>>

pub fn units_per_em(&self) -> Option<i32>

pub fn get_kerning_pair_adjustments( &self, glyphs: &[u16], adjustments: &mut [i32], ) -> bool

pub fn new_family_name_iterator(&self) -> impl Iterator<Item = LocalizedString>

pub fn family_name(&self) -> String

pub fn post_script_name(&self) -> Option<String>

pub fn resource_name(&self) -> Option<String>

pub fn to_font_data(&self) -> Option<(Vec<u8>, usize)>

pub fn bounds(&self) -> Rect

impl RCHandle<SkVertices>

pub const MAX_CUSTOM_ATTRIBUTES: usize = 8usize

pub fn new_copy( mode: SkVertices_VertexMode, positions: &[Point], texs: &[Point], colors: &[Color], indices: Option<&[u16]>, ) -> RCHandle<SkVertices>

pub fn unique_id(&self) -> u32

pub fn mode(&self) -> SkVertices_VertexMode

👎Deprecated since 0.29.0: will be removed without replacement

pub fn bounds(&self) -> &Rect

pub fn has_colors(&self) -> bool

👎Deprecated since 0.29.0: will be removed without replacement

pub fn has_tex_coords(&self) -> bool

👎Deprecated since 0.29.0: will be removed without replacement

pub fn has_bones(&self) -> bool

👎Deprecated since 0.29.0: returns false

pub fn has_indices(&self) -> bool

👎Deprecated since 0.29.0: will be removed without replacement

pub fn vertex_count(&self) -> usize

👎Deprecated since 0.29.0: will be removed without replacement

pub fn index_count(&self) -> usize

👎Deprecated since 0.29.0: will be removed without replacement

pub fn positions(&self) -> &[Point]

👎Deprecated since 0.29.0: will be removed without replacement

pub fn tex_coords(&self) -> Option<&[Point]>

👎Deprecated since 0.29.0: will be removed without replacement

pub fn colors(&self) -> Option<&[Color]>

👎Deprecated since 0.29.0: will be removed without replacement

pub fn bone_indices(&self) -> Option<&[[u32; 4]]>

👎Deprecated since 0.29.0: returns None

pub fn bone_weights(&self) -> Option<&[[u32; 4]]>

👎Deprecated since 0.29.0: returns None

pub fn indices(&self) -> Option<&[u16]>

👎Deprecated since 0.29.0: will be removed without replacement

pub fn is_volatile(&self) -> bool

👎Deprecated since 0.29.0: returns false

pub fn apply_bones(&self, _bones: &[Bone]) -> !

👎Deprecated since 0.29.0: removed without replacement

pub fn approximate_size(&self) -> usize

pub fn decode(_buffer: &[u8]) -> !

👎Deprecated since 0.31.0: removed without replacement

pub fn encode(&self) -> !

👎Deprecated since 0.31.0: removed without replacement

impl RCHandle<SkShader>

pub fn fractal_perlin_noise( base_frequency: (f32, f32), num_octaves: usize, seed: f32, tile_size: impl Into<Option<ISize>>, ) -> Option<RCHandle<SkShader>>

pub fn turbulence_perlin_noise( base_frequency: (f32, f32), num_octaves: usize, seed: f32, tile_size: impl Into<Option<ISize>>, ) -> Option<RCHandle<SkShader>>

impl RCHandle<SkPathEffect>

pub fn path_1d( path: &Handle<SkPath>, advance: f32, phase: f32, style: SkPath1DPathEffect_Style, ) -> Option<RCHandle<SkPathEffect>>

impl RCHandle<SkPathEffect>

pub fn line_2d(width: f32, matrix: &Matrix) -> Option<RCHandle<SkPathEffect>>

pub fn path_2d(matrix: &Matrix, path: &Handle<SkPath>) -> RCHandle<SkPathEffect>

impl RCHandle<SkBlender>

pub fn arithmetic( k1: f32, k2: f32, k3: f32, k4: f32, enforce_premul: bool, ) -> Option<RCHandle<SkBlender>>

impl RCHandle<SkColorFilter>

pub fn new_lighting( mul: impl Into<Color>, add: impl Into<Color>, ) -> Option<RCHandle<SkColorFilter>>

👎Deprecated since 0.56.0: Use color_filters::lighting()

impl RCHandle<SkPathEffect>

pub fn corner_path(radius: f32) -> Option<RCHandle<SkPathEffect>>

impl RCHandle<SkPathEffect>

pub fn dash(intervals: &[f32], phase: f32) -> Option<RCHandle<SkPathEffect>>

impl RCHandle<SkPathEffect>

pub fn discrete( seg_length: f32, dev: f32, seed_assist: impl Into<Option<u32>>, ) -> Option<RCHandle<SkPathEffect>>

impl RCHandle<SkShader>

pub fn linear_gradient<'a>( points: (impl Into<Point>, impl Into<Point>), colors: impl Into<GradientShaderColors<'a>>, pos: impl Into<Option<&'a [f32]>>, mode: SkTileMode, flags: impl Into<Option<Flags>>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

pub fn linear_gradient_with_interpolation<'a>( points: (impl Into<Point>, impl Into<Point>), colors: (&[Color4f], impl Into<Option<RCHandle<SkColorSpace>>>), pos: impl Into<Option<&'a [f32]>>, mode: SkTileMode, interpolation: impl Into<Interpolation>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

pub fn radial_gradient<'a>( center: impl Into<Point>, radius: f32, colors: impl Into<GradientShaderColors<'a>>, pos: impl Into<Option<&'a [f32]>>, mode: SkTileMode, flags: impl Into<Option<Flags>>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

pub fn radial_gradient_with_interpolation<'a>( center_and_radius: (impl Into<Point>, f32), colors: (&[Color4f], impl Into<Option<RCHandle<SkColorSpace>>>), pos: impl Into<Option<&'a [f32]>>, mode: SkTileMode, interpolation: impl Into<Interpolation>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

pub fn two_point_conical_gradient<'a>( start: impl Into<Point>, start_radius: f32, end: impl Into<Point>, end_radius: f32, colors: impl Into<GradientShaderColors<'a>>, pos: impl Into<Option<&'a [f32]>>, mode: SkTileMode, flags: impl Into<Option<Flags>>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

pub fn two_point_conical_gradient_with_interpolation<'a>( start_and_radius: (impl Into<Point>, f32), end_and_radius: (impl Into<Point>, f32), colors: (&[Color4f], impl Into<Option<RCHandle<SkColorSpace>>>), pos: impl Into<Option<&'a [f32]>>, mode: SkTileMode, interpolation: impl Into<Interpolation>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

pub fn sweep_gradient<'a>( center: impl Into<Point>, colors: impl Into<GradientShaderColors<'a>>, pos: impl Into<Option<&'a [f32]>>, mode: SkTileMode, angles: impl Into<Option<(f32, f32)>>, flags: impl Into<Option<Flags>>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

pub fn sweep_gradient_with_interpolation<'a>( center: impl Into<Point>, colors: (&[Color4f], impl Into<Option<RCHandle<SkColorSpace>>>), pos: impl Into<Option<&'a [f32]>>, mode: SkTileMode, angles: impl Into<Option<(f32, f32)>>, interpolation: impl Into<Interpolation>, local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

impl RCHandle<SkColorFilter>

pub fn high_contrast( config: &HighContrastConfig, ) -> Option<RCHandle<SkColorFilter>>

impl RCHandle<SkImageFilter>

pub fn arithmetic<'a>( inputs: impl Into<ArithmeticFPInputs>, background: impl Into<Option<RCHandle<SkImageFilter>>>, foreground: impl Into<Option<RCHandle<SkImageFilter>>>, crop_rect: impl Into<Option<&'a IRect>>, ) -> Option<RCHandle<SkImageFilter>>

arithmetic()

pub fn blur<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, sigma: (f32, f32), tile_mode: impl Into<Option<SkTileMode>>, ) -> Option<RCHandle<SkImageFilter>>

blur()

pub fn color_filter<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, cf: impl Into<RCHandle<SkColorFilter>>, ) -> Option<RCHandle<SkImageFilter>>

color_filter()

pub fn compose( outer: impl Into<RCHandle<SkImageFilter>>, inner: impl Into<RCHandle<SkImageFilter>>, ) -> Option<RCHandle<SkImageFilter>>

compose()

pub fn crop( rect: impl AsRef<Rect>, tile_mode: impl Into<Option<SkTileMode>>, input: impl Into<Option<RCHandle<SkImageFilter>>>, ) -> Option<RCHandle<SkImageFilter>>

crop()

pub fn displacement_map_effect<'a>( channel_selectors: (SkColorChannel, SkColorChannel), scale: f32, displacement: impl Into<Option<RCHandle<SkImageFilter>>>, color: impl Into<Option<RCHandle<SkImageFilter>>>, crop_rect: impl Into<Option<&'a IRect>>, ) -> Option<RCHandle<SkImageFilter>>

displacement_map()

pub fn distant_lit_diffuse_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, direction: impl Into<Point3>, light_color: impl Into<Color>, surface_scale: f32, kd: f32, ) -> Option<RCHandle<SkImageFilter>>

distant_lit_diffuse()

pub fn point_lit_diffuse_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, location: impl Into<Point3>, light_color: impl Into<Color>, surface_scale: f32, kd: f32, ) -> Option<RCHandle<SkImageFilter>>

point_lit_diffuse()

pub fn spot_lit_diffuse_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, location: impl Into<Point3>, target: impl Into<Point3>, specular_exponent: f32, cutoff_angle: f32, light_color: impl Into<Color>, surface_scale: f32, kd: f32, ) -> Option<RCHandle<SkImageFilter>>

spot_lit_diffuse()

pub fn distant_lit_specular_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, direction: impl Into<Point3>, light_color: impl Into<Color>, surface_scale: f32, ks: f32, shininess: f32, ) -> Option<RCHandle<SkImageFilter>>

distant_lit_specular()

pub fn point_lit_specular_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, location: impl Into<Point3>, light_color: impl Into<Color>, surface_scale: f32, ks: f32, shininess: f32, ) -> Option<RCHandle<SkImageFilter>>

point_lit_specular()

pub fn spot_lit_specular_lighting<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, location: impl Into<Point3>, target: impl Into<Point3>, specular_exponent: f32, cutoff_angle: f32, light_color: impl Into<Color>, surface_scale: f32, ks: f32, shininess: f32, ) -> Option<RCHandle<SkImageFilter>>

spot_lit_specular()

pub fn magnifier<'a>( self, lens_bounds: impl AsRef<Rect>, zoom_amount: f32, inset: f32, sampling_options: SamplingOptions, crop_rect: impl Into<Option<&'a IRect>>, ) -> Option<RCHandle<SkImageFilter>>

magnifier()

pub fn matrix_convolution<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, kernel_size: impl Into<ISize>, kernel: &[f32], gain: f32, bias: f32, kernel_offset: impl Into<IPoint>, tile_mode: SkTileMode, convolve_alpha: bool, ) -> Option<RCHandle<SkImageFilter>>

matrix_convolution()

pub fn merge<'a>( filters: impl IntoIterator<Item = Option<RCHandle<SkImageFilter>>>, crop_rect: impl Into<Option<&'a IRect>>, ) -> Option<RCHandle<SkImageFilter>>

merge()

pub fn dilate<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, radii: (f32, f32), ) -> Option<RCHandle<SkImageFilter>>

dilate()

pub fn erode<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, radii: (f32, f32), ) -> Option<RCHandle<SkImageFilter>>

erode()

pub fn offset<'a>( self, crop_rect: impl Into<Option<&'a IRect>>, delta: impl Into<Point>, ) -> Option<RCHandle<SkImageFilter>>

offset()

pub fn from_picture<'a>( picture: impl Into<RCHandle<SkPicture>>, crop_rect: impl Into<Option<&'a Rect>>, ) -> Option<RCHandle<SkImageFilter>>

self::picture()

pub fn tile( self, src: impl AsRef<Rect>, dst: impl AsRef<Rect>, ) -> Option<RCHandle<SkImageFilter>>

tile()

impl RCHandle<SkPicture>

pub fn as_image_filter<'a>( &self, crop_rect: impl Into<Option<&'a Rect>>, ) -> Option<RCHandle<SkImageFilter>>

pub fn into_image_filter<'a>( self, crop_rect: impl Into<Option<&'a Rect>>, ) -> Option<RCHandle<SkImageFilter>>

impl RCHandle<SkColorFilter>

pub fn luma() -> RCHandle<SkColorFilter>

impl RCHandle<SkColorFilter>

pub fn overdraw(colors: &[Color; 6]) -> RCHandle<SkColorFilter>

impl RCHandle<SkRuntimeEffect>

pub fn make_for_color_filter( sksl: impl AsRef<str>, options: impl for<'a, 'b> Into<Option<&'a Options<'b>>>, ) -> Result<RCHandle<SkRuntimeEffect>, String>

pub fn make_for_shader( sksl: impl AsRef<str>, options: impl for<'a, 'b> Into<Option<&'a Options<'b>>>, ) -> Result<RCHandle<SkRuntimeEffect>, String>

pub fn make_for_blender( sksl: impl AsRef<str>, options: impl for<'a, 'b> Into<Option<&'a Options<'b>>>, ) -> Result<RCHandle<SkRuntimeEffect>, String>

pub fn make_shader<'a>( &self, uniforms: impl Into<RCHandle<SkData>>, children: &[ChildPtr], local_matrix: impl Into<Option<&'a Matrix>>, ) -> Option<RCHandle<SkShader>>

pub fn make_color_filter<'a>( &self, inputs: impl Into<RCHandle<SkData>>, children: impl Into<Option<&'a [ChildPtr]>>, ) -> Option<RCHandle<SkColorFilter>>

pub fn make_blender<'a>( &self, uniforms: impl Into<RCHandle<SkData>>, children: impl Into<Option<&'a [ChildPtr]>>, ) -> Option<RCHandle<SkBlender>>

pub fn source(&self) -> &str

pub fn input_size(&self) -> usize

👎Deprecated since 0.35.0: Use uniform_size() instead

pub fn uniform_size(&self) -> usize

pub fn inputs(&self) -> &[Handle<SkRuntimeEffect_Uniform>]

👎Deprecated since 0.35.0: Use uniforms() instead

pub fn uniforms(&self) -> &[Handle<SkRuntimeEffect_Uniform>]

pub fn children(&self) -> &[Handle<SkRuntimeEffect_Child>]

pub fn find_input( &self, name: impl AsRef<str>, ) -> Option<&Handle<SkRuntimeEffect_Uniform>>

👎Deprecated since 0.35.0: Use find_uniform()

pub fn find_uniform( &self, name: impl AsRef<str>, ) -> Option<&Handle<SkRuntimeEffect_Uniform>>

pub fn find_child( &self, name: impl AsRef<str>, ) -> Option<&Handle<SkRuntimeEffect_Child>>

pub fn allow_shader(&self) -> bool

pub fn allow_color_filter(&self) -> bool

pub fn allow_blender(&self) -> bool

impl RCHandle<SkMaskFilter>

pub fn from_shader( shader: impl Into<RCHandle<SkShader>>, ) -> RCHandle<SkMaskFilter>

👎Deprecated since 0.76.0: ShaderMaskFilters will be deleted entirely in an upcoming Skia release.

impl RCHandle<SkColorFilter>

pub fn from_table(table: &[u8; 256]) -> RCHandle<SkColorFilter>

👎Deprecated since 0.56.0: Use color_filters::table()

pub fn from_argb( table_a: Option<&[u8; 256]>, table_r: Option<&[u8; 256]>, table_g: Option<&[u8; 256]>, table_b: Option<&[u8; 256]>, ) -> RCHandle<SkColorFilter>

👎Deprecated since 0.56.0: Use color_filters::table_argb()

impl RCHandle<SkMaskFilter>

pub fn table(table: &[u8; 256]) -> RCHandle<SkMaskFilter>

👎Deprecated since 0.76.0: TableMaskFilter will be remove entirely in an upcoming Skia release.

pub fn gamma(gamma: f32) -> RCHandle<SkMaskFilter>

👎Deprecated since 0.76.0: TableMaskFilter will be remove entirely in an upcoming Skia release.

pub fn clip(min: u8, max: u8) -> RCHandle<SkMaskFilter>

👎Deprecated since 0.76.0: TableMaskFilter will be remove entirely in an upcoming Skia release.

impl RCHandle<SkPathEffect>

pub fn trim( start_t: f32, stop_t: f32, mode: impl Into<Option<SkTrimPathEffect_Mode>>, ) -> Option<RCHandle<SkPathEffect>>

impl RCHandle<SkImage>

pub fn encode<'a>( &self, context: impl Into<Option<&'a mut RCHandle<GrDirectContext>>>, format: SkEncodedImageFormat, quality: impl Into<Option<u32>>, ) -> Option<RCHandle<SkData>>

impl RCHandle<GrDirectContext>

pub fn new_gl<'a>( interface: impl Into<RCHandle<GrGLInterface>>, options: impl Into<Option<&'a ContextOptions>>, ) -> Option<RCHandle<GrDirectContext>>

👎Deprecated since 0.74.0: use gpu::direct_contexts::make_gl()

pub fn reset( &mut self, backend_state: Option<u32>, ) -> &mut RCHandle<GrDirectContext>

pub fn reset_gl_texture_bindings(&mut self) -> &mut RCHandle<GrDirectContext>

pub fn abandon(&mut self) -> &mut RCHandle<GrDirectContext>

pub fn is_device_lost(&mut self) -> bool

pub fn oomed(&mut self) -> bool

pub fn release_resources_and_abandon( &mut self, ) -> &mut RCHandle<GrDirectContext>

pub fn resource_cache_limit(&self) -> usize

pub fn resource_cache_usage(&self) -> ResourceCacheUsage

pub fn resource_cache_purgeable_bytes(&self) -> usize

pub fn set_resource_cache_limits(&mut self, limits: ResourceCacheLimits)

pub fn set_resource_cache_limit(&mut self, max_resource_bytes: usize)

pub fn free_gpu_resources(&mut self) -> &mut RCHandle<GrDirectContext>

pub fn perform_deferred_cleanup( &mut self, not_used: Duration, opts: impl Into<Option<GrPurgeResourceOptions>>, ) -> &mut RCHandle<GrDirectContext>

pub fn purge_unlocked_resource_bytes( &mut self, bytes_to_purge: usize, prefer_scratch_resources: bool, ) -> &mut RCHandle<GrDirectContext>

pub fn purge_unlocked_resources( &mut self, opts: GrPurgeResourceOptions, ) -> &mut RCHandle<GrDirectContext>

pub fn supported_gpu_stats(&self) -> GpuStatsFlags

pub fn flush_and_submit(&mut self) -> &mut RCHandle<GrDirectContext>

pub fn flush_submit_and_sync_cpu(&mut self) -> &mut RCHandle<GrDirectContext>

pub fn flush_with_info(&mut self, info: &FlushInfo) -> GrSemaphoresSubmitted

👎Deprecated since 0.37.0: Use flush()

pub fn flush<'a>( &mut self, info: impl Into<Option<&'a FlushInfo>>, ) -> GrSemaphoresSubmitted

pub fn flush_image_with_info( &mut self, image: &RCHandle<SkImage>, info: &FlushInfo, ) -> GrSemaphoresSubmitted

pub fn flush_image(&mut self, image: &RCHandle<SkImage>)

pub fn flush_and_submit_image(&mut self, image: &RCHandle<SkImage>)

pub fn flush_surface_with_access( &mut self, surface: &mut RCHandle<SkSurface>, access: SkSurfaces_BackendSurfaceAccess, info: &FlushInfo, ) -> GrSemaphoresSubmitted

pub fn flush_surface_with_texture_state( &mut self, surface: &mut RCHandle<SkSurface>, info: &FlushInfo, new_state: Option<&RCHandle<skgpu_MutableTextureState>>, ) -> GrSemaphoresSubmitted

pub fn flush_and_submit_surface( &mut self, surface: &mut RCHandle<SkSurface>, sync_cpu: impl Into<Option<GrSyncCpu>>, )

pub fn flush_surface(&mut self, surface: &mut RCHandle<SkSurface>)

pub fn submit(&mut self, submit_info: impl Into<SubmitInfo>) -> bool

pub fn check_async_work_completion(&mut self)

pub fn supports_distance_field_text(&self) -> bool

pub fn compressed_backend_format( &self, compression: SkTextureCompressionType, ) -> Handle<GrBackendFormat>

pub fn set_backend_texture_state( &mut self, backend_texture: &RefHandle<GrBackendTexture>, state: &RCHandle<skgpu_MutableTextureState>, ) -> bool

pub fn set_backend_texture_state_and_return_previous( &mut self, backend_texture: &RefHandle<GrBackendTexture>, state: &RCHandle<skgpu_MutableTextureState>, ) -> Option<RCHandle<skgpu_MutableTextureState>>

pub fn set_backend_render_target_state( &mut self, target: &Handle<GrBackendRenderTarget>, state: &RCHandle<skgpu_MutableTextureState>, ) -> bool

pub fn set_backend_render_target_state_and_return_previous( &mut self, target: &Handle<GrBackendRenderTarget>, state: &RCHandle<skgpu_MutableTextureState>, ) -> Option<RCHandle<skgpu_MutableTextureState>>

pub fn delete_backend_texture(&mut self, texture: &RefHandle<GrBackendTexture>)

pub fn precompile_shader( &mut self, key: &RCHandle<SkData>, data: &RCHandle<SkData>, ) -> bool

pub fn id(&self) -> DirectContextId

impl RCHandle<GrGLInterface>

pub fn new_native() -> Option<RCHandle<GrGLInterface>>

pub fn new_load_with<F>(load_fn: F) -> Option<RCHandle<GrGLInterface>>

where F: FnMut(&str) -> *const c_void,

pub fn new_load_with_cstr<F>(load_fn: F) -> Option<RCHandle<GrGLInterface>>

where F: FnMut(&CStr) -> *const c_void,

pub fn validate(&self) -> bool

pub fn extensions(&self) -> &Handle<GrGLExtensions>

pub fn extensions_mut(&mut self) -> &mut Handle<GrGLExtensions>

pub fn has_extension(&self, extension: impl AsRef<str>) -> bool

impl RCHandle<GrRecordingContext>

pub fn as_direct_context(&mut self) -> Option<RCHandle<GrDirectContext>>

pub fn backend(&self) -> GrBackendApi

pub fn default_backend_format( &self, ct: ColorType, renderable: skgpu_Renderable, ) -> Handle<GrBackendFormat>

pub fn compressed_backend_format( &self, compression_type: SkTextureCompressionType, ) -> Handle<GrBackendFormat>

pub fn abandoned(&mut self) -> bool

pub fn color_type_supported_as_surface(&self, color_type: ColorType) -> bool

pub fn max_texture_size(&self) -> i32

pub fn max_render_target_size(&self) -> i32

pub fn color_type_supported_as_image(&self, color_type: ColorType) -> bool

pub fn supports_protected_content(&self) -> bool

pub fn max_surface_sample_count_for_color_type( &self, color_type: ColorType, ) -> usize

impl RCHandle<skgpu_MutableTextureState>

pub fn copied(&self) -> RCHandle<skgpu_MutableTextureState>

pub fn backend(&self) -> skgpu_BackendApi

impl RCHandle<skia_textlayout_FontCollection>

pub fn new() -> RCHandle<skia_textlayout_FontCollection>

pub fn font_managers_count(&self) -> usize

pub fn set_asset_font_manager( &mut self, font_manager: impl Into<Option<RCHandle<SkFontMgr>>>, )

pub fn set_dynamic_font_manager( &mut self, font_manager: impl Into<Option<RCHandle<SkFontMgr>>>, )

pub fn set_test_font_manager( &mut self, font_manager: impl Into<Option<RCHandle<SkFontMgr>>>, )

pub fn set_default_font_manager<'a>( &mut self, font_manager: impl Into<Option<RCHandle<SkFontMgr>>>, default_family_name: impl Into<Option<&'a str>>, )

pub fn set_default_font_manager_and_family_names( &mut self, font_manager: impl Into<Option<RCHandle<SkFontMgr>>>, family_names: &[impl AsRef<str>], )

pub fn fallback_manager(&self) -> Option<RCHandle<SkFontMgr>>

pub fn find_typefaces( &mut self, family_names: &[impl AsRef<str>], font_style: FontStyle, ) -> Vec<RCHandle<SkTypeface>>

pub fn find_typefaces_with_font_arguments<'fa>( &mut self, family_names: &[impl AsRef<str>], font_style: FontStyle, font_args: impl Into<Option<&'fa Handle<skia_textlayout_FontArguments>>>, ) -> Vec<RCHandle<SkTypeface>>

pub fn default_fallback_char( &mut self, unicode: i32, font_style: FontStyle, locale: impl AsRef<str>, ) -> Option<RCHandle<SkTypeface>>

pub fn default_fallback(&mut self) -> Option<RCHandle<SkTypeface>>

pub fn default_emoji_fallback( &mut self, emoji_start: i32, font_style: FontStyle, locale: impl AsRef<str>, ) -> Option<RCHandle<SkTypeface>>

pub fn disable_font_fallback(&mut self)

pub fn enable_font_fallback(&mut self)

pub fn font_fallback_enabled(&self) -> bool

pub fn paragraph_cache(&self) -> &Handle<skia_textlayout_ParagraphCache>

pub fn paragraph_cache_mut( &mut self, ) -> &mut Handle<skia_textlayout_ParagraphCache>

pub fn clear_caches(&mut self)

impl RCHandle<skia_textlayout_TypefaceFontStyleSet>

pub fn new( family_name: impl AsRef<str>, ) -> RCHandle<skia_textlayout_TypefaceFontStyleSet>

pub fn family_name(&self) -> &str

pub fn alias(&self) -> &str

pub fn append_typeface( &mut self, typeface: RCHandle<SkTypeface>, ) -> &mut RCHandle<skia_textlayout_TypefaceFontStyleSet>

impl RCHandle<skia_textlayout_TypefaceFontProvider>

pub fn new() -> RCHandle<skia_textlayout_TypefaceFontProvider>

pub fn register_typeface<'a>( &mut self, typeface: RCHandle<SkTypeface>, alias: impl Into<Option<&'a str>>, ) -> usize

impl RCHandle<skresources_ImageAsset>

pub fn is_multi_frame(&self) -> bool

pub fn from_data( data: impl Into<RCHandle<SkData>>, decode_strategy: impl Into<Option<skresources_ImageDecodeStrategy>>, ) -> Option<RCHandle<skresources_ImageAsset>>

impl RCHandle<SkSVGClipPath>

pub fn clip_path_units(&self) -> &SkSVGObjectBoundingBoxUnits_Type

pub fn set_clip_path_units(&mut self, value: SkSVGObjectBoundingBoxUnits_Type)

impl RCHandle<SkSVGContainer>

pub fn append_child(&mut self, node: impl Into<RCHandle<SkSVGNode>>)

pub fn children(&self) -> &[RCHandle<SkSVGNode>]

pub fn children_typed(&self) -> Vec<TypedNode>

impl RCHandle<SkSVGFeBlend>

pub fn input2(&self) -> &Input

pub fn set_input2(&mut self, value: Input)

pub fn mode(&self) -> &SkSVGFeBlend_Mode

pub fn set_mode(&mut self, value: SkSVGFeBlend_Mode)

impl RCHandle<SkSVGFeColorMatrix>

pub fn kind(&self) -> &SkSVGFeColorMatrixType

pub fn set_kind(&mut self, value: SkSVGFeColorMatrixType)

pub fn values(&self) -> &[f32]

impl RCHandle<SkSVGFeFunc>

pub fn func_a() -> RCHandle<SkSVGFeFunc>

pub fn func_r() -> RCHandle<SkSVGFeFunc>

pub fn func_g() -> RCHandle<SkSVGFeFunc>

pub fn func_b() -> RCHandle<SkSVGFeFunc>

pub fn table_values(&self) -> &[f32]

pub fn amplitude(&self) -> f32

pub fn set_amplitude(&mut self, value: f32)

pub fn exponent(&self) -> f32

pub fn set_exponent(&mut self, value: f32)

pub fn intercept(&self) -> f32

pub fn set_intercept(&mut self, value: f32)

pub fn offset(&self) -> f32

pub fn set_offset(&mut self, value: f32)

pub fn slope(&self) -> f32

pub fn set_slope(&mut self, value: f32)

pub fn kind(&self) -> &SkSVGFeFuncType

pub fn set_kind(&mut self, value: SkSVGFeFuncType)

impl RCHandle<SkSVGFeComposite>

pub fn input2(&self) -> &Input

pub fn set_input2(&mut self, value: Input)

pub fn k1(&self) -> f32

pub fn set_k1(&mut self, value: f32)

pub fn k2(&self) -> f32

pub fn set_k2(&mut self, value: f32)

pub fn k3(&self) -> f32

pub fn set_k3(&mut self, value: f32)

pub fn k4(&self) -> f32

pub fn set_k4(&mut self, value: f32)

pub fn operator(&self) -> &SkSVGFeCompositeOperator

pub fn set_operator(&mut self, value: SkSVGFeCompositeOperator)

impl RCHandle<SkSVGFeDisplacementMap>

pub fn input2(&self) -> &Input

pub fn set_input2(&mut self, value: Input)

pub fn x_channel_selector(&self) -> &SkColorChannel

pub fn set_x_channel_selector(&mut self, value: SkColorChannel)

pub fn y_channel_selector(&self) -> &SkColorChannel

pub fn set_y_channel_selector(&mut self, value: SkColorChannel)

pub fn scale(&self) -> &f32

pub fn set_scale(&mut self, value: f32)

impl RCHandle<SkSVGFeGaussianBlur>

pub fn std_deviation(&self) -> &StdDeviation

pub fn set_std_deviation(&mut self, value: StdDeviation)

impl RCHandle<SkSVGFeImage>

pub fn href(&self) -> &Handle<SkSVGIRI>

pub fn set_href(&mut self, value: Handle<SkSVGIRI>)

pub fn preserve_aspect_ratio(&self) -> &PreserveAspectRatio

pub fn set_preserve_aspect_ratio(&mut self, value: PreserveAspectRatio)

impl RCHandle<SkSVGFeDistantLight>

pub fn azimuth(&self) -> f32

pub fn set_azimuth(&mut self, value: f32)

pub fn elevation(&self) -> f32

pub fn set_elevation(&mut self, value: f32)

impl RCHandle<SkSVGFePointLight>

pub fn x(&self) -> f32

pub fn set_x(&mut self, value: f32)

pub fn y(&self) -> f32

pub fn set_y(&mut self, value: f32)

pub fn z(&self) -> f32

pub fn set_z(&mut self, value: f32)

impl RCHandle<SkSVGFeSpotLight>

pub fn x(&self) -> f32

pub fn set_x(&mut self, value: f32)

pub fn y(&self) -> f32

pub fn set_y(&mut self, value: f32)

pub fn z(&self) -> f32

pub fn set_z(&mut self, value: f32)

pub fn points_at_x(&self) -> f32

pub fn set_points_at_x(&mut self, value: f32)

pub fn points_at_y(&self) -> f32

pub fn set_points_at_y(&mut self, value: f32)

pub fn points_at_z(&self) -> f32

pub fn set_points_at_z(&mut self, value: f32)

pub fn specular_exponent(&self) -> f32

pub fn set_specular_exponent(&mut self, value: f32)

pub fn limiting_cone_angle(&self) -> Option<f32>

pub fn set_limiting_cone_angle(&mut self, value: f32)

impl RCHandle<SkSVGFeLighting>

pub fn surface_scale(&self) -> f32

pub fn set_surface_scale(&mut self, value: f32)

pub fn kernel_unit_length(&self) -> Option<KernelUnitLength>

pub fn set_kernel_unit_length(&mut self, value: KernelUnitLength)

impl RCHandle<SkSVGFeSpecularLighting>

pub fn specular_constant(&self) -> f32

pub fn set_specular_constant(&mut self, value: f32)

pub fn specular_exponent(&self) -> f32

pub fn set_specular_exponent(&mut self, value: f32)

impl RCHandle<SkSVGFeDiffuseLighting>

pub fn diffuse_constant(&self) -> f32

pub fn set_diffuse_constant(&mut self, value: f32)

impl RCHandle<SkSVGFeMergeNode>

pub fn input(&self) -> &Input

pub fn set_input(&mut self, value: Input)

impl RCHandle<SkSVGFeMorphology>

pub fn operator(&self) -> &SkSVGFeMorphology_Operator

pub fn set_operator(&mut self, value: SkSVGFeMorphology_Operator)

pub fn radius(&self) -> &Radius

pub fn set_radius(&mut self, value: Radius)

impl RCHandle<SkSVGFeOffset>

pub fn dx(&self) -> f32

pub fn set_dx(&mut self, value: f32)

pub fn dy(&self) -> f32

pub fn set_dy(&mut self, value: f32)

impl RCHandle<SkSVGFeTurbulence>

pub fn base_frequency(&self) -> &TurbulenceBaseFrequency

pub fn set_base_frequency(&mut self, value: TurbulenceBaseFrequency)

pub fn num_octaves(&self) -> i32

pub fn set_num_octaves(&mut self, value: i32)

pub fn seed(&self) -> f32

pub fn set_seed(&mut self, value: f32)

pub fn turbulence_type(&self) -> &SkSVGFeTurbulenceType_Type

pub fn set_turbulence_type(&mut self, value: SkSVGFeTurbulenceType_Type)

impl RCHandle<SkSVGFe>

pub fn input(&self) -> &Input

pub fn set_input(&mut self, value: Input)

pub fn result(&self) -> &Handle<SkString>

pub fn set_result(&mut self, value: Handle<SkString>)

pub fn x(&self) -> Option<&Length>

pub fn set_x(&mut self, value: Length)

pub fn y(&self) -> Option<&Length>

pub fn set_y(&mut self, value: Length)

pub fn width(&self) -> Option<&Length>

pub fn set_width(&mut self, value: Length)

pub fn height(&self) -> Option<&Length>

pub fn set_height(&mut self, value: Length)

impl RCHandle<SkSVGFilter>

pub fn x(&self) -> &Length

pub fn set_x(&mut self, value: Length)

pub fn y(&self) -> &Length

pub fn set_y(&mut self, value: Length)

pub fn width(&self) -> &Length

pub fn set_width(&mut self, value: Length)

pub fn height(&self) -> &Length

pub fn set_height(&mut self, value: Length)

pub fn filter_units(&self) -> &SkSVGObjectBoundingBoxUnits_Type

pub fn set_filter_units(&mut self, value: SkSVGObjectBoundingBoxUnits_Type)

pub fn primitive_units(&self) -> &SkSVGObjectBoundingBoxUnits_Type

pub fn set_primitive_units(&mut self, value: SkSVGObjectBoundingBoxUnits_Type)

impl RCHandle<SkSVGLinearGradient>

pub fn x1(&self) -> &Length

pub fn set_x1(&mut self, value: Length)

pub fn y1(&self) -> &Length

pub fn set_y1(&mut self, value: Length)

pub fn x2(&self) -> &Length

pub fn set_x2(&mut self, value: Length)

pub fn y2(&self) -> &Length

pub fn set_y2(&mut self, value: Length)

impl RCHandle<SkSVGRadialGradient>

pub fn cx(&self) -> &Length

pub fn set_cx(&mut self, value: Length)

pub fn cy(&self) -> &Length

pub fn set_cy(&mut self, value: Length)

pub fn r(&self) -> &Length

pub fn set_r(&mut self, value: Length)

pub fn fx(&self) -> Option<&Length>

pub fn set_fx(&mut self, value: Length)

pub fn fy(&self) -> Option<&Length>

pub fn set_fy(&mut self, value: Length)

impl RCHandle<SkSVGGradient>

pub fn href(&self) -> &Handle<SkSVGIRI>

pub fn set_href(&mut self, value: Handle<SkSVGIRI>)

pub fn gradient_transform(&self) -> &Matrix

pub fn set_gradient_transform(&mut self, value: Matrix)

pub fn spread_method(&self) -> &SkSVGSpreadMethod_Type

pub fn set_spread_method(&mut self, value: SkSVGSpreadMethod_Type)

pub fn gradient_units(&self) -> &SkSVGObjectBoundingBoxUnits_Type

pub fn set_gradient_units(&mut self, value: SkSVGObjectBoundingBoxUnits_Type)

impl RCHandle<SkSVGImage>

pub fn x(&self) -> &Length

pub fn set_x(&mut self, value: Length)

pub fn y(&self) -> &Length

pub fn set_y(&mut self, value: Length)

pub fn width(&self) -> &Length

pub fn set_width(&mut self, value: Length)

pub fn height(&self) -> &Length

pub fn set_height(&mut self, value: Length)

pub fn href(&self) -> &Handle<SkSVGIRI>

pub fn set_href(&mut self, value: Handle<SkSVGIRI>)

pub fn preserve_aspect_ratio(&self) -> &PreserveAspectRatio

pub fn set_preserve_aspect_ratio(&mut self, value: PreserveAspectRatio)

impl RCHandle<SkSVGMask>

pub fn x(&self) -> &Length

pub fn set_x(&mut self, value: Length)

pub fn y(&self) -> &Length

pub fn set_y(&mut self, value: Length)

pub fn width(&self) -> &Length

pub fn set_width(&mut self, value: Length)

pub fn height(&self) -> &Length

pub fn set_height(&mut self, value: Length)

pub fn mask_units(&self) -> &SkSVGObjectBoundingBoxUnits_Type

pub fn set_mask_units(&mut self, value: SkSVGObjectBoundingBoxUnits_Type)

pub fn mask_content_units(&self) -> &SkSVGObjectBoundingBoxUnits_Type

pub fn set_mask_content_units( &mut self, value: SkSVGObjectBoundingBoxUnits_Type, )

impl RCHandle<SkSVGNode>

pub fn tag(&self) -> SkSVGTag

pub fn typed(self) -> TypedNode

pub fn clip_rule(&self) -> Option<&SkSVGFillRule_Type>

pub fn set_clip_rule(&mut self, value: SkSVGFillRule_Type)

pub fn color_interpolation(&self) -> Option<&SkSVGColorspace>

pub fn set_color_interpolation(&mut self, value: SkSVGColorspace)

pub fn color_interpolation_filters(&self) -> Option<&SkSVGColorspace>

pub fn set_color_interpolation_filters(&mut self, value: SkSVGColorspace)

pub fn color(&self) -> Option<&Color>

pub fn set_color(&mut self, value: Color)

pub fn fill_rule(&self) -> Option<&SkSVGFillRule_Type>

pub fn set_fill_rule(&mut self, value: SkSVGFillRule_Type)

pub fn fill(&self) -> Option<&Handle<SkSVGPaint>>

pub fn set_fill(&mut self, value: Handle<SkSVGPaint>)

pub fn fill_opacity(&self) -> Option<f32>

pub fn set_fill_opacity(&mut self, value: f32)

pub fn font_family(&self) -> Option<&FontFamily>

pub fn set_font_family(&mut self, value: FontFamily)

pub fn font_size(&self) -> Option<&FontSize>

pub fn set_font_size(&mut self, value: FontSize)

pub fn font_style(&self) -> Option<&SkSVGFontStyle_Type>

pub fn set_font_style(&mut self, value: SkSVGFontStyle_Type)

pub fn font_weight(&self) -> Option<&SkSVGFontWeight_Type>

pub fn set_font_weight(&mut self, value: SkSVGFontWeight_Type)

pub fn stroke(&self) -> Option<&Handle<SkSVGPaint>>

pub fn set_stroke(&mut self, value: Handle<SkSVGPaint>)

pub fn stroke_line_cap(&self) -> Option<&SkSVGLineCap>

pub fn set_stroke_line_cap(&mut self, value: SkSVGLineCap)

pub fn stroke_line_join(&self) -> Option<&SkSVGLineJoin_Type>

pub fn set_stroke_line_join(&mut self, value: SkSVGLineJoin_Type)

pub fn stroke_miter_limit(&self) -> Option<f32>

pub fn set_stroke_miter_limit(&mut self, value: f32)

pub fn stroke_opacity(&self) -> Option<f32>

pub fn set_stroke_opacity(&mut self, value: f32)

pub fn stroke_width(&self) -> Option<&Length>

pub fn set_stroke_width(&mut self, value: Length)

pub fn text_anchor(&self) -> Option<&SkSVGTextAnchor_Type>

pub fn set_text_anchor(&mut self, value: SkSVGTextAnchor_Type)

pub fn visibility(&self) -> Option<&SkSVGVisibility_Type>

pub fn set_visibility(&mut self, value: SkSVGVisibility_Type)

pub fn clip_path(&self) -> Option<&Handle<SkSVGFuncIRI>>

pub fn set_clip_path(&mut self, value: Handle<SkSVGFuncIRI>)

pub fn display(&self) -> Option<&SkSVGDisplay>

pub fn set_display(&mut self, value: SkSVGDisplay)

pub fn mask(&self) -> Option<&Handle<SkSVGFuncIRI>>

pub fn set_mask(&mut self, value: Handle<SkSVGFuncIRI>)

pub fn filter(&self) -> Option<&Handle<SkSVGFuncIRI>>

pub fn set_filter(&mut self, value: Handle<SkSVGFuncIRI>)

pub fn opacity(&self) -> Option<f32>

pub fn set_opacity(&mut self, value: f32)

pub fn stop_color(&self) -> Option<&Handle<SkSVGColor>>

pub fn set_stop_color(&mut self, value: Handle<SkSVGColor>)

pub fn stop_opacity(&self) -> Option<f32>

pub fn set_stop_opacity(&mut self, value: f32)

pub fn flood_color(&self) -> Option<&Handle<SkSVGColor>>

pub fn set_flood_color(&mut self, value: Handle<SkSVGColor>)

pub fn flood_opacity(&self) -> Option<f32>

pub fn set_flood_opacity(&mut self, value: f32)

pub fn lighting_color(&self) -> Option<&Handle<SkSVGColor>>

pub fn set_lighting_color(&mut self, value: Handle<SkSVGColor>)

impl<T> RCHandle<T>

where T: NativeRefCounted + NodeSubtype,

pub fn as_base(&self) -> &RCHandle<<T as NodeSubtype>::Base>

pub fn as_base_mut(&mut self) -> &mut RCHandle<<T as NodeSubtype>::Base>

pub fn into_node(self) -> RCHandle<SkSVGNode>

All concrete node types can be converted to the supertype Node.

pub fn typed(self) -> TypedNode

All concrete node types can be converted to a TypedNode

impl RCHandle<SkSVGPattern>

pub fn href(&self) -> &Handle<SkSVGIRI>

pub fn set_href(&mut self, value: Handle<SkSVGIRI>)

pub fn x(&self) -> Option<&Length>

pub fn set_x(&mut self, value: Length)

pub fn y(&self) -> Option<&Length>

pub fn set_y(&mut self, value: Length)

pub fn width(&self) -> Option<&Length>

pub fn set_width(&mut self, value: Length)

pub fn height(&self) -> Option<&Length>

pub fn set_height(&mut self, value: Length)

pub fn pattern_transform(&self) -> Option<&Matrix>

pub fn set_pattern_transform(&mut self, value: Matrix)

impl RCHandle<SkSVGCircle>

pub fn cx(&self) -> &Length

pub fn set_cx(&mut self, value: Length)

pub fn cy(&self) -> &Length

pub fn set_cy(&mut self, value: Length)

pub fn r(&self) -> &Length

pub fn set_r(&mut self, value: Length)

impl RCHandle<SkSVGEllipse>

pub fn cx(&self) -> &Length

pub fn set_cx(&mut self, value: Length)

pub fn cy(&self) -> &Length

pub fn set_cy(&mut self, value: Length)

pub fn rx(&self) -> Option<&Length>

pub fn set_rx(&mut self, value: Length)

pub fn ry(&self) -> Option<&Length>

pub fn set_ry(&mut self, value: Length)

impl RCHandle<SkSVGLine>

pub fn x1(&self) -> &Length

pub fn set_x1(&mut self, value: Length)

pub fn y1(&self) -> &Length

pub fn set_y1(&mut self, value: Length)

pub fn x2(&self) -> &Length

pub fn set_x2(&mut self, value: Length)

pub fn y2(&self) -> &Length

pub fn set_y2(&mut self, value: Length)

impl RCHandle<SkSVGPath>

pub fn path(&self) -> &Handle<SkPath>

pub fn set_path(&mut self, value: Handle<SkPath>)

impl RCHandle<SkSVGPoly>

pub fn polygon() -> RCHandle<SkSVGPoly>

pub fn polyline() -> RCHandle<SkSVGPoly>

pub fn points(&self) -> &[Point]

impl RCHandle<SkSVGRect>

pub fn x(&self) -> &Length

pub fn set_x(&mut self, value: Length)

pub fn y(&self) -> &Length

pub fn set_y(&mut self, value: Length)

pub fn width(&self) -> &Length

pub fn set_width(&mut self, value: Length)

pub fn height(&self) -> &Length

pub fn set_height(&mut self, value: Length)

pub fn rx(&self) -> Option<&Length>

pub fn set_rx(&mut self, value: Length)

pub fn ry(&self) -> Option<&Length>

pub fn set_ry(&mut self, value: Length)

impl RCHandle<SkSVGStop>

pub fn offset(&self) -> &Length

pub fn set_offset(&mut self, value: Length)

impl RCHandle<SkSVGSVG>

pub fn new(kind: SkSVGSVG_Type) -> RCHandle<SkSVGSVG>

pub fn x(&self) -> &Length

pub fn set_x(&mut self, value: Length)

pub fn y(&self) -> &Length

pub fn set_y(&mut self, value: Length)

pub fn width(&self) -> &Length

pub fn set_width(&mut self, value: Length)

pub fn height(&self) -> &Length

pub fn set_height(&mut self, value: Length)

pub fn preserve_aspect_ratio(&self) -> &PreserveAspectRatio

pub fn set_preserve_aspect_ratio(&mut self, value: PreserveAspectRatio)

pub fn view_box(&self) -> Option<&Rect>

pub fn set_view_box(&mut self, value: Rect)

pub fn intrinsic_size(&self) -> Size

impl RCHandle<SkSVGTextContainer>

pub fn x(&self) -> &[Length]

pub fn y(&self) -> &[Length]

pub fn dx(&self) -> &[Length]

pub fn dy(&self) -> &[Length]

pub fn rotate(&self) -> &[f32]

pub fn xml_space(&self) -> &SkSVGXmlSpace

pub fn set_xml_space(&mut self, value: SkSVGXmlSpace)

impl RCHandle<SkSVGTextLiteral>

pub fn text(&self) -> &str

pub fn set_text(&mut self, value: &str)

impl RCHandle<SkSVGTextPath>

pub fn href(&self) -> &Handle<SkSVGIRI>

pub fn set_href(&mut self, value: Handle<SkSVGIRI>)

pub fn start_offset(&self) -> &Length

pub fn set_start_offset(&mut self, value: Length)

impl RCHandle<SkSVGTransformableNode>

pub fn set_transform(&mut self, transform: &Matrix)

pub fn transform(&self) -> &Matrix

impl RCHandle<SkSVGUse>

pub fn x(&self) -> &Length

pub fn set_x(&mut self, value: Length)

pub fn y(&self) -> &Length

pub fn set_y(&mut self, value: Length)

pub fn href(&self) -> &Handle<SkSVGIRI>

pub fn set_href(&mut self, value: Handle<SkSVGIRI>)

impl RCHandle<SkSVGDOM>

This type represents an SVG as a node-based data structure.

To convert an SVG to a Dom, a NativeResourceProvider is required.

Creating a Resource Provider

To create a resource provider, a crate::FontMgr is required at a minimum.

• If you don’t need font support, pass crate::FontMgr::new_empty() as the resource provider.
• To use the installed fonts on your system, pass crate::FontMgr::default() as the resource provider.

When you pass a crate::FontMgr as the resource provider, a crate::resources::LocalResourceProvider is created behind the scenes. This provider, in addition to supporting typefaces, also adds support for data: URLs.

Supporting External Resources

To support http:// or https:// external resources, enable the ureq feature and create a [crate::resources::UReqResourceProvider].

Custom Resource Providers

If you need more customization, you can implement the trait crate::resources::ResourceProvider.

pub fn read<R>( reader: R, resource_provider: impl Into<RCHandle<RustResourceProvider>>, ) -> Result<RCHandle<SkSVGDOM>, LoadError>

where R: Read,

pub fn from_str( svg: impl AsRef<str>, resource_provider: impl Into<RCHandle<RustResourceProvider>>, ) -> Result<RCHandle<SkSVGDOM>, LoadError>

pub fn from_bytes( svg: &[u8], resource_provider: impl Into<RCHandle<RustResourceProvider>>, ) -> Result<RCHandle<SkSVGDOM>, LoadError>

pub fn root(&self) -> RCHandle<SkSVGSVG>

pub fn render(&self, canvas: &Canvas)

pub fn set_container_size(&mut self, size: impl Into<Size>)

impl RCHandle<SkOrderedFontMgr>

pub fn new() -> RCHandle<SkOrderedFontMgr>

pub fn append(&mut self, font_mgr: impl Into<RCHandle<SkFontMgr>>)

Methods from Deref<Target = [u8]>

pub fn is_ascii(&self) -> bool

Checks if all bytes in this slice are within the ASCII range.

pub fn as_ascii(&self) -> Option<&[AsciiChar]>

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

If this slice is_ascii, returns it as a slice of ASCII characters, otherwise returns None.

pub unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar]

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

Converts this slice of bytes into a slice of ASCII characters, without checking whether they’re valid.

Safety

Every byte in the slice must be in 0..=127, or else this is UB.

pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool

Checks that two slices are an ASCII case-insensitive match.

Same as to_ascii_lowercase(a) == to_ascii_lowercase(b), but without allocating and copying temporaries.

pub fn make_ascii_uppercase(&mut self)

Converts this slice to its ASCII upper case equivalent in-place.

ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.

To return a new uppercased value without modifying the existing one, use to_ascii_uppercase.

pub fn make_ascii_lowercase(&mut self)

Converts this slice to its ASCII lower case equivalent in-place.

ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.

To return a new lowercased value without modifying the existing one, use to_ascii_lowercase.

pub fn escape_ascii(&self) -> EscapeAscii<'_>

Returns an iterator that produces an escaped version of this slice, treating it as an ASCII string.

Examples

let s = b"0\t\r\n'\"\\\x9d";
let escaped = s.escape_ascii().to_string();
assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");

pub fn trim_ascii_start(&self) -> &[u8]

Returns a byte slice with leading ASCII whitespace bytes removed.

‘Whitespace’ refers to the definition used by u8::is_ascii_whitespace.

Examples

assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");

pub fn trim_ascii_end(&self) -> &[u8]

Returns a byte slice with trailing ASCII whitespace bytes removed.

‘Whitespace’ refers to the definition used by u8::is_ascii_whitespace.

Examples

assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world");
assert_eq!(b"  ".trim_ascii_end(), b"");
assert_eq!(b"".trim_ascii_end(), b"");

pub fn trim_ascii(&self) -> &[u8]

Returns a byte slice with leading and trailing ASCII whitespace bytes removed.

‘Whitespace’ refers to the definition used by u8::is_ascii_whitespace.

Examples

assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");
assert_eq!(b"  ".trim_ascii(), b"");
assert_eq!(b"".trim_ascii(), b"");

pub fn len(&self) -> usize

Returns the number of elements in the slice.

Examples

let a = [1, 2, 3];
assert_eq!(a.len(), 3);

pub fn is_empty(&self) -> bool

Returns true if the slice has a length of 0.

Examples

let a = [1, 2, 3];
assert!(!a.is_empty());

let b: &[i32] = &[];
assert!(b.is_empty());

pub fn first(&self) -> Option<&T>

Returns the first element of the slice, or None if it is empty.

Examples

let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());

pub fn first_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the first element of the slice, or None if it is empty.

Examples

let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.first_mut());

pub fn split_first(&self) -> Option<(&T, &[T])>

Returns the first and all the rest of the elements of the slice, or None if it is empty.

Examples

let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}

pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>

Returns the first and all the rest of the elements of the slice, or None if it is empty.

Examples

let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_mut() {
    *first = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[3, 4, 5]);

pub fn split_last(&self) -> Option<(&T, &[T])>

Returns the last and all the rest of the elements of the slice, or None if it is empty.

Examples

let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}

pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>

Returns the last and all the rest of the elements of the slice, or None if it is empty.

Examples

let x = &mut [0, 1, 2];

if let Some((last, elements)) = x.split_last_mut() {
    *last = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[4, 5, 3]);

pub fn last(&self) -> Option<&T>

Returns the last element of the slice, or None if it is empty.

Examples

let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());

pub fn last_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the last item in the slice, or None if it is empty.

Examples

let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

let y: &mut [i32] = &mut [];
assert_eq!(None, y.last_mut());

pub fn first_chunk<const N: usize>(&self) -> Option<&[T; N]>

Returns an array reference to the first N items in the slice.

If the slice is not at least N in length, this will return None.

Examples

let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());

pub fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>

Returns a mutable array reference to the first N items in the slice.

If the slice is not at least N in length, this will return None.

Examples

let x = &mut [0, 1, 2];

if let Some(first) = x.first_chunk_mut::<2>() {
    first[0] = 5;
    first[1] = 4;
}
assert_eq!(x, &[5, 4, 2]);

assert_eq!(None, x.first_chunk_mut::<4>());

pub fn split_first_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])>

Returns an array reference to the first N items in the slice and the remaining slice.

If the slice is not at least N in length, this will return None.

Examples

let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk::<2>() {
    assert_eq!(first, &[0, 1]);
    assert_eq!(elements, &[2]);
}

assert_eq!(None, x.split_first_chunk::<4>());

pub fn split_first_chunk_mut<const N: usize>( &mut self, ) -> Option<(&mut [T; N], &mut [T])>

Returns a mutable array reference to the first N items in the slice and the remaining slice.

If the slice is not at least N in length, this will return None.

Examples

let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk_mut::<2>() {
    first[0] = 3;
    first[1] = 4;
    elements[0] = 5;
}
assert_eq!(x, &[3, 4, 5]);

assert_eq!(None, x.split_first_chunk_mut::<4>());

pub fn split_last_chunk<const N: usize>(&self) -> Option<(&[T], &[T; N])>

Returns an array reference to the last N items in the slice and the remaining slice.

If the slice is not at least N in length, this will return None.

Examples

let x = &[0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk::<2>() {
    assert_eq!(elements, &[0]);
    assert_eq!(last, &[1, 2]);
}

assert_eq!(None, x.split_last_chunk::<4>());

pub fn split_last_chunk_mut<const N: usize>( &mut self, ) -> Option<(&mut [T], &mut [T; N])>

Returns a mutable array reference to the last N items in the slice and the remaining slice.

If the slice is not at least N in length, this will return None.

Examples

let x = &mut [0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk_mut::<2>() {
    last[0] = 3;
    last[1] = 4;
    elements[0] = 5;
}
assert_eq!(x, &[5, 3, 4]);

assert_eq!(None, x.split_last_chunk_mut::<4>());

pub fn last_chunk<const N: usize>(&self) -> Option<&[T; N]>

Returns an array reference to the last N items in the slice.

If the slice is not at least N in length, this will return None.

Examples

let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());

pub fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>

Returns a mutable array reference to the last N items in the slice.

If the slice is not at least N in length, this will return None.

Examples

let x = &mut [0, 1, 2];

if let Some(last) = x.last_chunk_mut::<2>() {
    last[0] = 10;
    last[1] = 20;
}
assert_eq!(x, &[0, 10, 20]);

assert_eq!(None, x.last_chunk_mut::<4>());

pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>

where I: SliceIndex<[T]>,

Returns a reference to an element or subslice depending on the type of index.

• If given a position, returns a reference to the element at that position or None if out of bounds.
• If given a range, returns the subslice corresponding to that range, or None if out of bounds.

Examples

let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));

pub fn get_mut<I>( &mut self, index: I, ) -> Option<&mut <I as SliceIndex<[T]>>::Output>

where I: SliceIndex<[T]>,

Returns a mutable reference to an element or subslice depending on the type of index (see get) or None if the index is out of bounds.

Examples

let x = &mut [0, 1, 2];

if let Some(elem) = x.get_mut(1) {
    *elem = 42;
}
assert_eq!(x, &[0, 42, 2]);

pub unsafe fn get_unchecked<I>( &self, index: I, ) -> &<I as SliceIndex<[T]>>::Output

where I: SliceIndex<[T]>,

Returns a reference to an element or subslice, without doing bounds checking.

For a safe alternative see get.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

You can think of this like .get(index).unwrap_unchecked(). It’s UB to call .get_unchecked(len), even if you immediately convert to a pointer. And it’s UB to call .get_unchecked(..len + 1), .get_unchecked(..=len), or similar.

Examples

let x = &[1, 2, 4];

unsafe {
    assert_eq!(x.get_unchecked(1), &2);
}

pub unsafe fn get_unchecked_mut<I>( &mut self, index: I, ) -> &mut <I as SliceIndex<[T]>>::Output

where I: SliceIndex<[T]>,

Returns a mutable reference to an element or subslice, without doing bounds checking.

For a safe alternative see get_mut.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

You can think of this like .get_mut(index).unwrap_unchecked(). It’s UB to call .get_unchecked_mut(len), even if you immediately convert to a pointer. And it’s UB to call .get_unchecked_mut(..len + 1), .get_unchecked_mut(..=len), or similar.

Examples

let x = &mut [1, 2, 4];

unsafe {
    let elem = x.get_unchecked_mut(1);
    *elem = 13;
}
assert_eq!(x, &[1, 13, 4]);

pub fn as_ptr(&self) -> *const T

Returns a raw pointer to the slice’s buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up dangling.

The caller must also ensure that the memory the pointer (non-transitively) points to is never written to (except inside an UnsafeCell) using this pointer or any pointer derived from it. If you need to mutate the contents of the slice, use as_mut_ptr.

Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.

Examples

let x = &[1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));
    }
}

pub fn as_mut_ptr(&mut self) -> *mut T

Returns an unsafe mutable pointer to the slice’s buffer.

The caller must ensure that the slice outlives the pointer this function returns, or else it will end up dangling.

Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.

Examples

let x = &mut [1, 2, 4];
let x_ptr = x.as_mut_ptr();

unsafe {
    for i in 0..x.len() {
        *x_ptr.add(i) += 2;
    }
}
assert_eq!(x, &[3, 4, 6]);

pub fn as_ptr_range(&self) -> Range<*const T>

Returns the two raw pointers spanning the slice.

The returned range is half-open, which means that the end pointer points one past the last element of the slice. This way, an empty slice is represented by two equal pointers, and the difference between the two pointers represents the size of the slice.

See as_ptr for warnings on using these pointers. The end pointer requires extra caution, as it does not point to a valid element in the slice.

This function is useful for interacting with foreign interfaces which use two pointers to refer to a range of elements in memory, as is common in C++.

It can also be useful to check if a pointer to an element refers to an element of this slice:

let a = [1, 2, 3];
let x = &a[1] as *const _;
let y = &5 as *const _;

assert!(a.as_ptr_range().contains(&x));
assert!(!a.as_ptr_range().contains(&y));

pub fn as_mut_ptr_range(&mut self) -> Range<*mut T>

Returns the two unsafe mutable pointers spanning the slice.

The returned range is half-open, which means that the end pointer points one past the last element of the slice. This way, an empty slice is represented by two equal pointers, and the difference between the two pointers represents the size of the slice.

See as_mut_ptr for warnings on using these pointers. The end pointer requires extra caution, as it does not point to a valid element in the slice.

This function is useful for interacting with foreign interfaces which use two pointers to refer to a range of elements in memory, as is common in C++.

pub fn as_array<const N: usize>(&self) -> Option<&[T; N]>

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

Gets a reference to the underlying array.

If N is not exactly equal to the length of self, then this method returns None.

pub fn as_mut_array<const N: usize>(&mut self) -> Option<&mut [T; N]>

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

Gets a mutable reference to the slice’s underlying array.

If N is not exactly equal to the length of self, then this method returns None.

pub fn swap(&mut self, a: usize, b: usize)

Swaps two elements in the slice.

If a equals to b, it’s guaranteed that elements won’t change value.

Arguments

• a - The index of the first element
• b - The index of the second element

Panics

Panics if a or b are out of bounds.

Examples

let mut v = ["a", "b", "c", "d", "e"];
v.swap(2, 4);
assert!(v == ["a", "b", "e", "d", "c"]);

pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)

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

Swaps two elements in the slice, without doing bounds checking.

For a safe alternative see swap.

Arguments

• a - The index of the first element
• b - The index of the second element

Safety

Calling this method with an out-of-bounds index is undefined behavior. The caller has to ensure that a < self.len() and b < self.len().

Examples

#![feature(slice_swap_unchecked)]

let mut v = ["a", "b", "c", "d"];
// SAFETY: we know that 1 and 3 are both indices of the slice
unsafe { v.swap_unchecked(1, 3) };
assert!(v == ["a", "d", "c", "b"]);

pub fn reverse(&mut self)

Reverses the order of elements in the slice, in place.

Examples

let mut v = [1, 2, 3];
v.reverse();
assert!(v == [3, 2, 1]);

pub fn iter(&self) -> Iter<'_, T>

Returns an iterator over the slice.

The iterator yields all items from start to end.

Examples

let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator that allows modifying each value.

The iterator yields all items from start to end.

Examples

let x = &mut [1, 2, 4];
for elem in x.iter_mut() {
    *elem += 2;
}
assert_eq!(x, &[3, 4, 6]);

pub fn windows(&self, size: usize) -> Windows<'_, T>

Returns an iterator over all contiguous windows of length size. The windows overlap. If the slice is shorter than size, the iterator returns no values.

Panics

Panics if size is zero.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.windows(3);
assert_eq!(iter.next().unwrap(), &['l', 'o', 'r']);
assert_eq!(iter.next().unwrap(), &['o', 'r', 'e']);
assert_eq!(iter.next().unwrap(), &['r', 'e', 'm']);
assert!(iter.next().is_none());

If the slice is shorter than size:

let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());

Because the Iterator trait cannot represent the required lifetimes, there is no windows_mut analog to windows; [0,1,2].windows_mut(2).collect() would violate the rules of references (though a LendingIterator analog is possible). You can sometimes use Cell::as_slice_of_cells in conjunction with windows instead:

use std::cell::Cell;

let mut array = ['R', 'u', 's', 't', ' ', '2', '0', '1', '5'];
let slice = &mut array[..];
let slice_of_cells: &[Cell<char>] = Cell::from_mut(slice).as_slice_of_cells();
for w in slice_of_cells.windows(3) {
    Cell::swap(&w[0], &w[2]);
}
assert_eq!(array, ['s', 't', ' ', '2', '0', '1', '5', 'u', 'R']);

pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See chunks_exact for a variant of this iterator that returns chunks of always exactly chunk_size elements, and rchunks for the same iterator but starting at the end of the slice.

If your chunk_size is a constant, consider using as_chunks instead, which will give references to arrays of exactly that length, rather than slices.

Panics

Panics if chunk_size is zero.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.chunks(2);
assert_eq!(iter.next().unwrap(), &['l', 'o']);
assert_eq!(iter.next().unwrap(), &['r', 'e']);
assert_eq!(iter.next().unwrap(), &['m']);
assert!(iter.next().is_none());

pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See chunks_exact_mut for a variant of this iterator that returns chunks of always exactly chunk_size elements, and rchunks_mut for the same iterator but starting at the end of the slice.

If your chunk_size is a constant, consider using as_chunks_mut instead, which will give references to arrays of exactly that length, rather than slices.

Panics

Panics if chunk_size is zero.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.chunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 3]);

pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved from the remainder function of the iterator.

Due to each chunk having exactly chunk_size elements, the compiler can often optimize the resulting code better than in the case of chunks.

See chunks for a variant of this iterator that also returns the remainder as a smaller chunk, and rchunks_exact for the same iterator but starting at the end of the slice.

If your chunk_size is a constant, consider using as_chunks instead, which will give references to arrays of exactly that length, rather than slices.

Panics

Panics if chunk_size is zero.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.chunks_exact(2);
assert_eq!(iter.next().unwrap(), &['l', 'o']);
assert_eq!(iter.next().unwrap(), &['r', 'e']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['m']);

pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the beginning of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved from the into_remainder function of the iterator.

Due to each chunk having exactly chunk_size elements, the compiler can often optimize the resulting code better than in the case of chunks_mut.

See chunks_mut for a variant of this iterator that also returns the remainder as a smaller chunk, and rchunks_exact_mut for the same iterator but starting at the end of the slice.

If your chunk_size is a constant, consider using as_chunks_mut instead, which will give references to arrays of exactly that length, rather than slices.

Panics

Panics if chunk_size is zero.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.chunks_exact_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 0]);

pub unsafe fn as_chunks_unchecked<const N: usize>(&self) -> &[[T; N]]

Splits the slice into a slice of N-element arrays, assuming that there’s no remainder.

This is the inverse operation to as_flattened.

As this is unsafe, consider whether you could use as_chunks or as_rchunks instead, perhaps via something like if let (chunks, []) = slice.as_chunks() or let (chunks, []) = slice.as_chunks() else { unreachable!() };.

Safety

This may only be called when

• The slice splits exactly into N-element chunks (aka self.len() % N == 0).
• N != 0.

Examples

let slice: &[char] = &['l', 'o', 'r', 'e', 'm', '!'];
let chunks: &[[char; 1]] =
    // SAFETY: 1-element chunks never have remainder
    unsafe { slice.as_chunks_unchecked() };
assert_eq!(chunks, &[['l'], ['o'], ['r'], ['e'], ['m'], ['!']]);
let chunks: &[[char; 3]] =
    // SAFETY: The slice length (6) is a multiple of 3
    unsafe { slice.as_chunks_unchecked() };
assert_eq!(chunks, &[['l', 'o', 'r'], ['e', 'm', '!']]);

// These would be unsound:
// let chunks: &[[_; 5]] = slice.as_chunks_unchecked() // The slice length is not a multiple of 5
// let chunks: &[[_; 0]] = slice.as_chunks_unchecked() // Zero-length chunks are never allowed

pub fn as_chunks<const N: usize>(&self) -> (&[[T; N]], &[T])

Splits the slice into a slice of N-element arrays, starting at the beginning of the slice, and a remainder slice with length strictly less than N.

The remainder is meaningful in the division sense. Given let (chunks, remainder) = slice.as_chunks(), then:

• chunks.len() equals slice.len() / N,
• remainder.len() equals slice.len() % N, and
• slice.len() equals chunks.len() * N + remainder.len().

You can flatten the chunks back into a slice-of-T with as_flattened.

Panics

Panics if N is zero.

Note that this check is against a const generic parameter, not a runtime value, and thus a particular monomorphization will either always panic or it will never panic.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let (chunks, remainder) = slice.as_chunks();
assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
assert_eq!(remainder, &['m']);

If you expect the slice to be an exact multiple, you can combine let-else with an empty slice pattern:

let slice = ['R', 'u', 's', 't'];
let (chunks, []) = slice.as_chunks::<2>() else {
    panic!("slice didn't have even length")
};
assert_eq!(chunks, &[['R', 'u'], ['s', 't']]);

pub fn as_rchunks<const N: usize>(&self) -> (&[T], &[[T; N]])

Splits the slice into a slice of N-element arrays, starting at the end of the slice, and a remainder slice with length strictly less than N.

The remainder is meaningful in the division sense. Given let (remainder, chunks) = slice.as_rchunks(), then:

• remainder.len() equals slice.len() % N,
• chunks.len() equals slice.len() / N, and
• slice.len() equals chunks.len() * N + remainder.len().

You can flatten the chunks back into a slice-of-T with as_flattened.

Panics

Panics if N is zero.

Note that this check is against a const generic parameter, not a runtime value, and thus a particular monomorphization will either always panic or it will never panic.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);

pub unsafe fn as_chunks_unchecked_mut<const N: usize>( &mut self, ) -> &mut [[T; N]]

Splits the slice into a slice of N-element arrays, assuming that there’s no remainder.

This is the inverse operation to as_flattened_mut.

As this is unsafe, consider whether you could use as_chunks_mut or as_rchunks_mut instead, perhaps via something like if let (chunks, []) = slice.as_chunks_mut() or let (chunks, []) = slice.as_chunks_mut() else { unreachable!() };.

Safety

This may only be called when

• The slice splits exactly into N-element chunks (aka self.len() % N == 0).
• N != 0.

Examples

let slice: &mut [char] = &mut ['l', 'o', 'r', 'e', 'm', '!'];
let chunks: &mut [[char; 1]] =
    // SAFETY: 1-element chunks never have remainder
    unsafe { slice.as_chunks_unchecked_mut() };
chunks[0] = ['L'];
assert_eq!(chunks, &[['L'], ['o'], ['r'], ['e'], ['m'], ['!']]);
let chunks: &mut [[char; 3]] =
    // SAFETY: The slice length (6) is a multiple of 3
    unsafe { slice.as_chunks_unchecked_mut() };
chunks[1] = ['a', 'x', '?'];
assert_eq!(slice, &['L', 'o', 'r', 'a', 'x', '?']);

// These would be unsound:
// let chunks: &[[_; 5]] = slice.as_chunks_unchecked_mut() // The slice length is not a multiple of 5
// let chunks: &[[_; 0]] = slice.as_chunks_unchecked_mut() // Zero-length chunks are never allowed

pub fn as_chunks_mut<const N: usize>(&mut self) -> (&mut [[T; N]], &mut [T])

Splits the slice into a slice of N-element arrays, starting at the beginning of the slice, and a remainder slice with length strictly less than N.

The remainder is meaningful in the division sense. Given let (chunks, remainder) = slice.as_chunks_mut(), then:

• chunks.len() equals slice.len() / N,
• remainder.len() equals slice.len() % N, and
• slice.len() equals chunks.len() * N + remainder.len().

You can flatten the chunks back into a slice-of-T with as_flattened_mut.

Panics

Panics if N is zero.

Note that this check is against a const generic parameter, not a runtime value, and thus a particular monomorphization will either always panic or it will never panic.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (chunks, remainder) = v.as_chunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 9]);

pub fn as_rchunks_mut<const N: usize>(&mut self) -> (&mut [T], &mut [[T; N]])

Splits the slice into a slice of N-element arrays, starting at the end of the slice, and a remainder slice with length strictly less than N.

The remainder is meaningful in the division sense. Given let (remainder, chunks) = slice.as_rchunks_mut(), then:

• remainder.len() equals slice.len() % N,
• chunks.len() equals slice.len() / N, and
• slice.len() equals chunks.len() * N + remainder.len().

You can flatten the chunks back into a slice-of-T with as_flattened_mut.

Panics

Panics if N is zero.

Note that this check is against a const generic parameter, not a runtime value, and thus a particular monomorphization will either always panic or it will never panic.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (remainder, chunks) = v.as_rchunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[9, 1, 1, 2, 2]);

pub fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N>

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

Returns an iterator over overlapping windows of N elements of a slice, starting at the beginning of the slice.

This is the const generic equivalent of windows.

If N is greater than the size of the slice, it will return no windows.

Panics

Panics if N is zero. This check will most probably get changed to a compile time error before this method gets stabilized.

Examples

#![feature(array_windows)]
let slice = [0, 1, 2, 3];
let mut iter = slice.array_windows();
assert_eq!(iter.next().unwrap(), &[0, 1]);
assert_eq!(iter.next().unwrap(), &[1, 2]);
assert_eq!(iter.next().unwrap(), &[2, 3]);
assert!(iter.next().is_none());

pub fn rchunks(&self, chunk_size: usize) -> RChunks<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See rchunks_exact for a variant of this iterator that returns chunks of always exactly chunk_size elements, and chunks for the same iterator but starting at the beginning of the slice.

If your chunk_size is a constant, consider using as_rchunks instead, which will give references to arrays of exactly that length, rather than slices.

Panics

Panics if chunk_size is zero.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());

pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last chunk will not have length chunk_size.

See rchunks_exact_mut for a variant of this iterator that returns chunks of always exactly chunk_size elements, and chunks_mut for the same iterator but starting at the beginning of the slice.

If your chunk_size is a constant, consider using as_rchunks_mut instead, which will give references to arrays of exactly that length, rather than slices.

Panics

Panics if chunk_size is zero.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);

pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

The chunks are slices and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved from the remainder function of the iterator.

Due to each chunk having exactly chunk_size elements, the compiler can often optimize the resulting code better than in the case of rchunks.

See rchunks for a variant of this iterator that also returns the remainder as a smaller chunk, and chunks_exact for the same iterator but starting at the beginning of the slice.

If your chunk_size is a constant, consider using as_rchunks instead, which will give references to arrays of exactly that length, rather than slices.

Panics

Panics if chunk_size is zero.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);

pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, T>

Returns an iterator over chunk_size elements of the slice at a time, starting at the end of the slice.

The chunks are mutable slices, and do not overlap. If chunk_size does not divide the length of the slice, then the last up to chunk_size-1 elements will be omitted and can be retrieved from the into_remainder function of the iterator.

Due to each chunk having exactly chunk_size elements, the compiler can often optimize the resulting code better than in the case of chunks_mut.

See rchunks_mut for a variant of this iterator that also returns the remainder as a smaller chunk, and chunks_exact_mut for the same iterator but starting at the beginning of the slice.

If your chunk_size is a constant, consider using as_rchunks_mut instead, which will give references to arrays of exactly that length, rather than slices.

Panics

Panics if chunk_size is zero.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_exact_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[0, 2, 2, 1, 1]);

pub fn chunk_by<F>(&self, pred: F) -> ChunkBy<'_, T, F>

where F: FnMut(&T, &T) -> bool,

Returns an iterator over the slice producing non-overlapping runs of elements using the predicate to separate them.

The predicate is called for every pair of consecutive elements, meaning that it is called on slice[0] and slice[1], followed by slice[1] and slice[2], and so on.

Examples

let slice = &[1, 1, 1, 3, 3, 2, 2, 2];

let mut iter = slice.chunk_by(|a, b| a == b);

assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
assert_eq!(iter.next(), Some(&[3, 3][..]));
assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
assert_eq!(iter.next(), None);

This method can be used to extract the sorted subslices:

let slice = &[1, 1, 2, 3, 2, 3, 2, 3, 4];

let mut iter = slice.chunk_by(|a, b| a <= b);

assert_eq!(iter.next(), Some(&[1, 1, 2, 3][..]));
assert_eq!(iter.next(), Some(&[2, 3][..]));
assert_eq!(iter.next(), Some(&[2, 3, 4][..]));
assert_eq!(iter.next(), None);

pub fn chunk_by_mut<F>(&mut self, pred: F) -> ChunkByMut<'_, T, F>

where F: FnMut(&T, &T) -> bool,

Returns an iterator over the slice producing non-overlapping mutable runs of elements using the predicate to separate them.

The predicate is called for every pair of consecutive elements, meaning that it is called on slice[0] and slice[1], followed by slice[1] and slice[2], and so on.

Examples

let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2];

let mut iter = slice.chunk_by_mut(|a, b| a == b);

assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
assert_eq!(iter.next(), Some(&mut [3, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
assert_eq!(iter.next(), None);

This method can be used to extract the sorted subslices:

let slice = &mut [1, 1, 2, 3, 2, 3, 2, 3, 4];

let mut iter = slice.chunk_by_mut(|a, b| a <= b);

assert_eq!(iter.next(), Some(&mut [1, 1, 2, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 3, 4][..]));
assert_eq!(iter.next(), None);

pub fn split_at(&self, mid: usize) -> (&[T], &[T])

Divides one slice into two at an index.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Panics

Panics if mid > len. For a non-panicking alternative see split_at_checked.

Examples

let v = ['a', 'b', 'c'];

{
   let (left, right) = v.split_at(0);
   assert_eq!(left, []);
   assert_eq!(right, ['a', 'b', 'c']);
}

{
    let (left, right) = v.split_at(2);
    assert_eq!(left, ['a', 'b']);
    assert_eq!(right, ['c']);
}

{
    let (left, right) = v.split_at(3);
    assert_eq!(left, ['a', 'b', 'c']);
    assert_eq!(right, []);
}

pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])

Divides one mutable slice into two at an index.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Panics

Panics if mid > len. For a non-panicking alternative see split_at_mut_checked.

Examples

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_at_mut(2);
assert_eq!(left, [1, 0]);
assert_eq!(right, [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T])

Divides one slice into two at an index, without doing bounds checking.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

For a safe alternative see split_at.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used. The caller has to ensure that 0 <= mid <= self.len().

Examples

let v = ['a', 'b', 'c'];

unsafe {
   let (left, right) = v.split_at_unchecked(0);
   assert_eq!(left, []);
   assert_eq!(right, ['a', 'b', 'c']);
}

unsafe {
    let (left, right) = v.split_at_unchecked(2);
    assert_eq!(left, ['a', 'b']);
    assert_eq!(right, ['c']);
}

unsafe {
    let (left, right) = v.split_at_unchecked(3);
    assert_eq!(left, ['a', 'b', 'c']);
    assert_eq!(right, []);
}

pub unsafe fn split_at_mut_unchecked( &mut self, mid: usize, ) -> (&mut [T], &mut [T])

Divides one mutable slice into two at an index, without doing bounds checking.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

For a safe alternative see split_at_mut.

Safety

Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used. The caller has to ensure that 0 <= mid <= self.len().

Examples

let mut v = [1, 0, 3, 0, 5, 6];
// scoped to restrict the lifetime of the borrows
unsafe {
    let (left, right) = v.split_at_mut_unchecked(2);
    assert_eq!(left, [1, 0]);
    assert_eq!(right, [3, 0, 5, 6]);
    left[1] = 2;
    right[1] = 4;
}
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn split_at_checked(&self, mid: usize) -> Option<(&[T], &[T])>

Divides one slice into two at an index, returning None if the slice is too short.

If mid ≤ len returns a pair of slices where the first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Otherwise, if mid > len, returns None.

Examples

let v = [1, -2, 3, -4, 5, -6];

{
   let (left, right) = v.split_at_checked(0).unwrap();
   assert_eq!(left, []);
   assert_eq!(right, [1, -2, 3, -4, 5, -6]);
}

{
    let (left, right) = v.split_at_checked(2).unwrap();
    assert_eq!(left, [1, -2]);
    assert_eq!(right, [3, -4, 5, -6]);
}

{
    let (left, right) = v.split_at_checked(6).unwrap();
    assert_eq!(left, [1, -2, 3, -4, 5, -6]);
    assert_eq!(right, []);
}

assert_eq!(None, v.split_at_checked(7));

pub fn split_at_mut_checked( &mut self, mid: usize, ) -> Option<(&mut [T], &mut [T])>

Divides one mutable slice into two at an index, returning None if the slice is too short.

If mid ≤ len returns a pair of slices where the first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Otherwise, if mid > len, returns None.

Examples

let mut v = [1, 0, 3, 0, 5, 6];

if let Some((left, right)) = v.split_at_mut_checked(2) {
    assert_eq!(left, [1, 0]);
    assert_eq!(right, [3, 0, 5, 6]);
    left[1] = 2;
    right[1] = 4;
}
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

assert_eq!(None, v.split_at_mut_checked(7));

pub fn split<F>(&self, pred: F) -> Split<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred. The matched element is not contained in the subslices.

Examples

let slice = [10, 40, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

If the first element is matched, an empty slice will be the first item returned by the iterator. Similarly, if the last element in the slice is matched, an empty slice will be the last item returned by the iterator:

let slice = [10, 40, 33];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[]);
assert!(iter.next().is_none());

If two matched elements are directly adjacent, an empty slice will be present between them:

let slice = [10, 6, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10]);
assert_eq!(iter.next().unwrap(), &[]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over mutable subslices separated by elements that match pred. The matched element is not contained in the subslices.

Examples

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.split_mut(|num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(v, [1, 40, 30, 1, 60, 1]);

pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred. The matched element is contained in the end of the previous subslice as a terminator.

Examples

let slice = [10, 40, 33, 20];
let mut iter = slice.split_inclusive(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

If the last element of the slice is matched, that element will be considered the terminator of the preceding slice. That slice will be the last item returned by the iterator.

let slice = [3, 10, 40, 33];
let mut iter = slice.split_inclusive(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[3]);
assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
assert!(iter.next().is_none());

pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over mutable subslices separated by elements that match pred. The matched element is contained in the previous subslice as a terminator.

Examples

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.split_inclusive_mut(|num| *num % 3 == 0) {
    let terminator_idx = group.len()-1;
    group[terminator_idx] = 1;
}
assert_eq!(v, [10, 40, 1, 20, 1, 1]);

pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.

Examples

let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);

As with split(), if the first or last element is matched, an empty slice will be the first (or last) item returned by the iterator.

let v = &[0, 1, 1, 2, 3, 5, 8];
let mut it = v.rsplit(|n| *n % 2 == 0);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next().unwrap(), &[3, 5]);
assert_eq!(it.next().unwrap(), &[1, 1]);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next(), None);

pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over mutable subslices separated by elements that match pred, starting at the end of the slice and working backwards. The matched element is not contained in the subslices.

Examples

let mut v = [100, 400, 300, 200, 600, 500];

let mut count = 0;
for group in v.rsplit_mut(|num| *num % 3 == 0) {
    count += 1;
    group[0] = count;
}
assert_eq!(v, [3, 400, 300, 2, 600, 1]);

pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred, limited to returning at most n items. The matched element is not contained in the subslices.

The last element returned, if any, will contain the remainder of the slice.

Examples

Print the slice split once by numbers divisible by 3 (i.e., [10, 40], [20, 60, 50]):

let v = [10, 40, 30, 20, 60, 50];

for group in v.splitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}

pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over mutable subslices separated by elements that match pred, limited to returning at most n items. The matched element is not contained in the subslices.

The last element returned, if any, will contain the remainder of the slice.

Examples

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.splitn_mut(2, |num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(v, [1, 40, 30, 1, 60, 50]);

pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred limited to returning at most n items. This starts at the end of the slice and works backwards. The matched element is not contained in the subslices.

The last element returned, if any, will contain the remainder of the slice.

Examples

Print the slice split once, starting from the end, by numbers divisible by 3 (i.e., [50], [10, 40, 30, 20]):

let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}

pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, F>

where F: FnMut(&T) -> bool,

Returns an iterator over subslices separated by elements that match pred limited to returning at most n items. This starts at the end of the slice and works backwards. The matched element is not contained in the subslices.

The last element returned, if any, will contain the remainder of the slice.

Examples

let mut s = [10, 40, 30, 20, 60, 50];

for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(s, [1, 40, 30, 20, 60, 1]);

pub fn split_once<F>(&self, pred: F) -> Option<(&[T], &[T])>

where F: FnMut(&T) -> bool,

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

Splits the slice on the first element that matches the specified predicate.

If any matching elements are present in the slice, returns the prefix before the match and suffix after. The matching element itself is not included. If no elements match, returns None.

Examples

#![feature(slice_split_once)]
let s = [1, 2, 3, 2, 4];
assert_eq!(s.split_once(|&x| x == 2), Some((
    &[1][..],
    &[3, 2, 4][..]
)));
assert_eq!(s.split_once(|&x| x == 0), None);

pub fn rsplit_once<F>(&self, pred: F) -> Option<(&[T], &[T])>

where F: FnMut(&T) -> bool,

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

Splits the slice on the last element that matches the specified predicate.

If any matching elements are present in the slice, returns the prefix before the match and suffix after. The matching element itself is not included. If no elements match, returns None.

Examples

#![feature(slice_split_once)]
let s = [1, 2, 3, 2, 4];
assert_eq!(s.rsplit_once(|&x| x == 2), Some((
    &[1, 2, 3][..],
    &[4][..]
)));
assert_eq!(s.rsplit_once(|&x| x == 0), None);

pub fn contains(&self, x: &T) -> bool

where T: PartialEq,

Returns true if the slice contains an element with the given value.

This operation is O(n).

Note that if you have a sorted slice, binary_search may be faster.

Examples

let v = [10, 40, 30];
assert!(v.contains(&30));
assert!(!v.contains(&50));

If you do not have a &T, but some other value that you can compare with one (for example, String implements PartialEq<str>), you can use iter().any:

let v = [String::from("hello"), String::from("world")]; // slice of `String`
assert!(v.iter().any(|e| e == "hello")); // search with `&str`
assert!(!v.iter().any(|e| e == "hi"));

pub fn starts_with(&self, needle: &[T]) -> bool

where T: PartialEq,

Returns true if needle is a prefix of the slice or equal to the slice.

Examples

let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(v.starts_with(&v));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));

Always returns true if needle is an empty slice:

let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));

pub fn ends_with(&self, needle: &[T]) -> bool

where T: PartialEq,

Returns true if needle is a suffix of the slice or equal to the slice.

Examples

let v = [10, 40, 30];
assert!(v.ends_with(&[30]));
assert!(v.ends_with(&[40, 30]));
assert!(v.ends_with(&v));
assert!(!v.ends_with(&[50]));
assert!(!v.ends_with(&[50, 30]));

Always returns true if needle is an empty slice:

let v = &[10, 40, 30];
assert!(v.ends_with(&[]));
let v: &[u8] = &[];
assert!(v.ends_with(&[]));

pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>

where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

Returns a subslice with the prefix removed.

If the slice starts with prefix, returns the subslice after the prefix, wrapped in Some. If prefix is empty, simply returns the original slice. If prefix is equal to the original slice, returns an empty slice.

If the slice does not start with prefix, returns None.

Examples

let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));

pub fn strip_suffix<P>(&self, suffix: &P) -> Option<&[T]>

where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

Returns a subslice with the suffix removed.

If the slice ends with suffix, returns the subslice before the suffix, wrapped in Some. If suffix is empty, simply returns the original slice. If suffix is equal to the original slice, returns an empty slice.

If the slice does not end with suffix, returns None.

Examples

let v = &[10, 40, 30];
assert_eq!(v.strip_suffix(&[30]), Some(&[10, 40][..]));
assert_eq!(v.strip_suffix(&[40, 30]), Some(&[10][..]));
assert_eq!(v.strip_suffix(&[10, 40, 30]), Some(&[][..]));
assert_eq!(v.strip_suffix(&[50]), None);
assert_eq!(v.strip_suffix(&[50, 30]), None);

pub fn trim_prefix<P>(&self, prefix: &P) -> &[T]

where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

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

Returns a subslice with the optional prefix removed.

If the slice starts with prefix, returns the subslice after the prefix. If prefix is empty or the slice does not start with prefix, simply returns the original slice. If prefix is equal to the original slice, returns an empty slice.

Examples

#![feature(trim_prefix_suffix)]

let v = &[10, 40, 30];

// Prefix present - removes it
assert_eq!(v.trim_prefix(&[10]), &[40, 30][..]);
assert_eq!(v.trim_prefix(&[10, 40]), &[30][..]);
assert_eq!(v.trim_prefix(&[10, 40, 30]), &[][..]);

// Prefix absent - returns original slice
assert_eq!(v.trim_prefix(&[50]), &[10, 40, 30][..]);
assert_eq!(v.trim_prefix(&[10, 50]), &[10, 40, 30][..]);

let prefix : &str = "he";
assert_eq!(b"hello".trim_prefix(prefix.as_bytes()), b"llo".as_ref());

pub fn trim_suffix<P>(&self, suffix: &P) -> &[T]

where P: SlicePattern<Item = T> + ?Sized, T: PartialEq,

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

Returns a subslice with the optional suffix removed.

If the slice ends with suffix, returns the subslice before the suffix. If suffix is empty or the slice does not end with suffix, simply returns the original slice. If suffix is equal to the original slice, returns an empty slice.

Examples

#![feature(trim_prefix_suffix)]

let v = &[10, 40, 30];

// Suffix present - removes it
assert_eq!(v.trim_suffix(&[30]), &[10, 40][..]);
assert_eq!(v.trim_suffix(&[40, 30]), &[10][..]);
assert_eq!(v.trim_suffix(&[10, 40, 30]), &[][..]);

// Suffix absent - returns original slice
assert_eq!(v.trim_suffix(&[50]), &[10, 40, 30][..]);
assert_eq!(v.trim_suffix(&[50, 30]), &[10, 40, 30][..]);

pub fn binary_search(&self, x: &T) -> Result<usize, usize>

where T: Ord,

Binary searches this slice for a given element. If the slice is not sorted, the returned result is unspecified and meaningless.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. The index is chosen deterministically, but is subject to change in future versions of Rust. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See also binary_search_by, binary_search_by_key, and partition_point.

Examples

Looks up a series of four elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r { Ok(1..=4) => true, _ => false, });

If you want to find that whole range of matching items, rather than an arbitrary matching one, that can be done using partition_point:

let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let low = s.partition_point(|x| x < &1);
assert_eq!(low, 1);
let high = s.partition_point(|x| x <= &1);
assert_eq!(high, 5);
let r = s.binary_search(&1);
assert!((low..high).contains(&r.unwrap()));

assert!(s[..low].iter().all(|&x| x < 1));
assert!(s[low..high].iter().all(|&x| x == 1));
assert!(s[high..].iter().all(|&x| x > 1));

// For something not found, the "range" of equal items is empty
assert_eq!(s.partition_point(|x| x < &11), 9);
assert_eq!(s.partition_point(|x| x <= &11), 9);
assert_eq!(s.binary_search(&11), Err(9));

If you want to insert an item to a sorted vector, while maintaining sort order, consider using partition_point:

let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
// If `num` is unique, `s.partition_point(|&x| x < num)` (with `<`) is equivalent to
// `s.binary_search(&num).unwrap_or_else(|x| x)`, but using `<=` will allow `insert`
// to shift less elements.
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>

where F: FnMut(&'a T) -> Ordering,

Binary searches this slice with a comparator function.

The comparator function should return an order code that indicates whether its argument is Less, Equal or Greater the desired target. If the slice is not sorted or if the comparator function does not implement an order consistent with the sort order of the underlying slice, the returned result is unspecified and meaningless.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. The index is chosen deterministically, but is subject to change in future versions of Rust. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See also binary_search, binary_search_by_key, and partition_point.

Examples

Looks up a series of four elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let seek = 13;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
let seek = 4;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
let seek = 100;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
let seek = 1;
let r = s.binary_search_by(|probe| probe.cmp(&seek));
assert!(match r { Ok(1..=4) => true, _ => false, });

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F, ) -> Result<usize, usize>

where F: FnMut(&'a T) -> B, B: Ord,

Binary searches this slice with a key extraction function.

Assumes that the slice is sorted by the key, for instance with sort_by_key using the same key extraction function. If the slice is not sorted by the key, the returned result is unspecified and meaningless.

If the value is found then Result::Ok is returned, containing the index of the matching element. If there are multiple matches, then any one of the matches could be returned. The index is chosen deterministically, but is subject to change in future versions of Rust. If the value is not found then Result::Err is returned, containing the index where a matching element could be inserted while maintaining sorted order.

See also binary_search, binary_search_by, and partition_point.

Examples

Looks up a series of four elements in a slice of pairs sorted by their second elements. The first is found, with a uniquely determined position; the second and third are not found; the fourth could match any position in [1, 4].

let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a, b)| b);
assert!(match r { Ok(1..=4) => true, _ => false, });

pub fn sort_unstable(&mut self)

where T: Ord,

Sorts the slice in ascending order without preserving the initial order of equal elements.

This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not allocate), and O(n * log(n)) worst-case.

If the implementation of Ord for T does not implement a total order, the function may panic; even if the function exits normally, the resulting order of elements in the slice is unspecified. See also the note on panicking below.

For example |a, b| (a - b).cmp(a) is a comparison function that is neither transitive nor reflexive nor total, a < b < c < a with a = 1, b = 2, c = 3. For more information and examples see the Ord documentation.

All original elements will remain in the slice and any possible modifications via interior mutability are observed in the input. Same is true if the implementation of Ord for T panics.

Sorting types that only implement PartialOrd such as f32 and f64 require additional precautions. For example, f32::NAN != f32::NAN, which doesn’t fulfill the reflexivity requirement of Ord. By using an alternative comparison function with slice::sort_unstable_by such as f32::total_cmp or f64::total_cmp that defines a total order users can sort slices containing floating-point values. Alternatively, if all values in the slice are guaranteed to be in a subset for which PartialOrd::partial_cmp forms a total order, it’s possible to sort the slice with sort_unstable_by(|a, b| a.partial_cmp(b).unwrap()).

Current implementation

The current implementation is based on ipnsort by Lukas Bergdoll and Orson Peters, which combines the fast average case of quicksort with the fast worst case of heapsort, achieving linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the expected time to sort the data is O(n * log(k)).

It is typically faster than stable sorting, except in a few special cases, e.g., when the slice is partially sorted.

Panics

May panic if the implementation of Ord for T does not implement a total order, or if the Ord implementation panics.

Examples

let mut v = [4, -5, 1, -3, 2];

v.sort_unstable();
assert_eq!(v, [-5, -3, 1, 2, 4]);

pub fn sort_unstable_by<F>(&mut self, compare: F)

where F: FnMut(&T, &T) -> Ordering,

Sorts the slice in ascending order with a comparison function, without preserving the initial order of equal elements.

This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not allocate), and O(n * log(n)) worst-case.

If the comparison function compare does not implement a total order, the function may panic; even if the function exits normally, the resulting order of elements in the slice is unspecified. See also the note on panicking below.

For example |a, b| (a - b).cmp(a) is a comparison function that is neither transitive nor reflexive nor total, a < b < c < a with a = 1, b = 2, c = 3. For more information and examples see the Ord documentation.

All original elements will remain in the slice and any possible modifications via interior mutability are observed in the input. Same is true if compare panics.

Current implementation

The current implementation is based on ipnsort by Lukas Bergdoll and Orson Peters, which combines the fast average case of quicksort with the fast worst case of heapsort, achieving linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the expected time to sort the data is O(n * log(k)).

It is typically faster than stable sorting, except in a few special cases, e.g., when the slice is partially sorted.

Panics

May panic if the compare does not implement a total order, or if the compare itself panics.

Examples

let mut v = [4, -5, 1, -3, 2];
v.sort_unstable_by(|a, b| a.cmp(b));
assert_eq!(v, [-5, -3, 1, 2, 4]);

// reverse sorting
v.sort_unstable_by(|a, b| b.cmp(a));
assert_eq!(v, [4, 2, 1, -3, -5]);

pub fn sort_unstable_by_key<K, F>(&mut self, f: F)

where F: FnMut(&T) -> K, K: Ord,

Sorts the slice in ascending order with a key extraction function, without preserving the initial order of equal elements.

This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not allocate), and O(n * log(n)) worst-case.

If the implementation of Ord for K does not implement a total order, the function may panic; even if the function exits normally, the resulting order of elements in the slice is unspecified. See also the note on panicking below.

For example |a, b| (a - b).cmp(a) is a comparison function that is neither transitive nor reflexive nor total, a < b < c < a with a = 1, b = 2, c = 3. For more information and examples see the Ord documentation.

All original elements will remain in the slice and any possible modifications via interior mutability are observed in the input. Same is true if the implementation of Ord for K panics.

Current implementation

The current implementation is based on ipnsort by Lukas Bergdoll and Orson Peters, which combines the fast average case of quicksort with the fast worst case of heapsort, achieving linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the expected time to sort the data is O(n * log(k)).

It is typically faster than stable sorting, except in a few special cases, e.g., when the slice is partially sorted.

Panics

May panic if the implementation of Ord for K does not implement a total order, or if the Ord implementation panics.

Examples

let mut v = [4i32, -5, 1, -3, 2];

v.sort_unstable_by_key(|k| k.abs());
assert_eq!(v, [1, 2, -3, 4, -5]);

pub fn select_nth_unstable( &mut self, index: usize, ) -> (&mut [T], &mut T, &mut [T])

where T: Ord,

Reorders the slice such that the element at index is at a sort-order position. All elements before index will be <= to this value, and all elements after will be >= to it.

This reordering is unstable (i.e. any element that compares equal to the nth element may end up at that position), in-place (i.e. does not allocate), and runs in O(n) time. This function is also known as “kth element” in other libraries.

Returns a triple that partitions the reordered slice:

• The unsorted subslice before index, whose elements all satisfy x <= self[index].

• The element at index.

• The unsorted subslice after index, whose elements all satisfy x >= self[index].

Current implementation

The current algorithm is an introselect implementation based on ipnsort by Lukas Bergdoll and Orson Peters, which is also the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for pivot selection, which guarantees linear runtime for all inputs.

Panics

Panics when index >= len(), and so always panics on empty slices.

May panic if the implementation of Ord for T does not implement a total order.

Examples

let mut v = [-5i32, 4, 2, -3, 1];

// Find the items `<=` to the median, the median itself, and the items `>=` to it.
let (lesser, median, greater) = v.select_nth_unstable(2);

assert!(lesser == [-3, -5] || lesser == [-5, -3]);
assert_eq!(median, &mut 1);
assert!(greater == [4, 2] || greater == [2, 4]);

// We are only guaranteed the slice will be one of the following, based on the way we sort
// about the specified index.
assert!(v == [-3, -5, 1, 2, 4] ||
        v == [-5, -3, 1, 2, 4] ||
        v == [-3, -5, 1, 4, 2] ||
        v == [-5, -3, 1, 4, 2]);

pub fn select_nth_unstable_by<F>( &mut self, index: usize, compare: F, ) -> (&mut [T], &mut T, &mut [T])

where F: FnMut(&T, &T) -> Ordering,

Reorders the slice with a comparator function such that the element at index is at a sort-order position. All elements before index will be <= to this value, and all elements after will be >= to it, according to the comparator function.

This reordering is unstable (i.e. any element that compares equal to the nth element may end up at that position), in-place (i.e. does not allocate), and runs in O(n) time. This function is also known as “kth element” in other libraries.

Returns a triple partitioning the reordered slice:

• The unsorted subslice before index, whose elements all satisfy compare(x, self[index]).is_le().

• The element at index.

• The unsorted subslice after index, whose elements all satisfy compare(x, self[index]).is_ge().

Current implementation

The current algorithm is an introselect implementation based on ipnsort by Lukas Bergdoll and Orson Peters, which is also the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for pivot selection, which guarantees linear runtime for all inputs.

Panics

Panics when index >= len(), and so always panics on empty slices.

May panic if compare does not implement a total order.

Examples

let mut v = [-5i32, 4, 2, -3, 1];

// Find the items `>=` to the median, the median itself, and the items `<=` to it, by using
// a reversed comparator.
let (before, median, after) = v.select_nth_unstable_by(2, |a, b| b.cmp(a));

assert!(before == [4, 2] || before == [2, 4]);
assert_eq!(median, &mut 1);
assert!(after == [-3, -5] || after == [-5, -3]);

// We are only guaranteed the slice will be one of the following, based on the way we sort
// about the specified index.
assert!(v == [2, 4, 1, -5, -3] ||
        v == [2, 4, 1, -3, -5] ||
        v == [4, 2, 1, -5, -3] ||
        v == [4, 2, 1, -3, -5]);

pub fn select_nth_unstable_by_key<K, F>( &mut self, index: usize, f: F, ) -> (&mut [T], &mut T, &mut [T])

where F: FnMut(&T) -> K, K: Ord,

Reorders the slice with a key extraction function such that the element at index is at a sort-order position. All elements before index will have keys <= to the key at index, and all elements after will have keys >= to it.

This reordering is unstable (i.e. any element that compares equal to the nth element may end up at that position), in-place (i.e. does not allocate), and runs in O(n) time. This function is also known as “kth element” in other libraries.

Returns a triple partitioning the reordered slice:

• The unsorted subslice before index, whose elements all satisfy f(x) <= f(self[index]).

• The element at index.

• The unsorted subslice after index, whose elements all satisfy f(x) >= f(self[index]).

Current implementation

The current algorithm is an introselect implementation based on ipnsort by Lukas Bergdoll and Orson Peters, which is also the basis for sort_unstable. The fallback algorithm is Median of Medians using Tukey’s Ninther for pivot selection, which guarantees linear runtime for all inputs.

Panics

Panics when index >= len(), meaning it always panics on empty slices.

May panic if K: Ord does not implement a total order.

Examples

let mut v = [-5i32, 4, 1, -3, 2];

// Find the items `<=` to the absolute median, the absolute median itself, and the items
// `>=` to it.
let (lesser, median, greater) = v.select_nth_unstable_by_key(2, |a| a.abs());

assert!(lesser == [1, 2] || lesser == [2, 1]);
assert_eq!(median, &mut -3);
assert!(greater == [4, -5] || greater == [-5, 4]);

// We are only guaranteed the slice will be one of the following, based on the way we sort
// about the specified index.
assert!(v == [1, 2, -3, 4, -5] ||
        v == [1, 2, -3, -5, 4] ||
        v == [2, 1, -3, 4, -5] ||
        v == [2, 1, -3, -5, 4]);

pub fn partition_dedup(&mut self) -> (&mut [T], &mut [T])

where T: PartialEq,

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

Moves all consecutive repeated elements to the end of the slice according to the PartialEq trait implementation.

Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.

If the slice is sorted, the first returned slice contains no duplicates.

Examples

#![feature(slice_partition_dedup)]

let mut slice = [1, 2, 2, 3, 3, 2, 1, 1];

let (dedup, duplicates) = slice.partition_dedup();

assert_eq!(dedup, [1, 2, 3, 2, 1]);
assert_eq!(duplicates, [2, 3, 1]);

pub fn partition_dedup_by<F>(&mut self, same_bucket: F) -> (&mut [T], &mut [T])

where F: FnMut(&mut T, &mut T) -> bool,

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

Moves all but the first of consecutive elements to the end of the slice satisfying a given equality relation.

Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.

The same_bucket function is passed references to two elements from the slice and must determine if the elements compare equal. The elements are passed in opposite order from their order in the slice, so if same_bucket(a, b) returns true, a is moved at the end of the slice.

If the slice is sorted, the first returned slice contains no duplicates.

Examples

#![feature(slice_partition_dedup)]

let mut slice = ["foo", "Foo", "BAZ", "Bar", "bar", "baz", "BAZ"];

let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.eq_ignore_ascii_case(b));

assert_eq!(dedup, ["foo", "BAZ", "Bar", "baz"]);
assert_eq!(duplicates, ["bar", "Foo", "BAZ"]);

pub fn partition_dedup_by_key<K, F>(&mut self, key: F) -> (&mut [T], &mut [T])

where F: FnMut(&mut T) -> K, K: PartialEq,

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

Moves all but the first of consecutive elements to the end of the slice that resolve to the same key.

Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.

If the slice is sorted, the first returned slice contains no duplicates.

Examples

#![feature(slice_partition_dedup)]

let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];

let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);

assert_eq!(dedup, [10, 20, 30, 20, 11]);
assert_eq!(duplicates, [21, 30, 13]);

pub fn rotate_left(&mut self, mid: usize)

Rotates the slice in-place such that the first mid elements of the slice move to the end while the last self.len() - mid elements move to the front.

After calling rotate_left, the element previously at index mid will become the first element in the slice.

Panics

This function will panic if mid is greater than the length of the slice. Note that mid == self.len() does not panic and is a no-op rotation.

Complexity

Takes linear (in self.len()) time.

Examples

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.rotate_left(2);
assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);

Rotating a subslice:

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a[1..5].rotate_left(1);
assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);

pub fn rotate_right(&mut self, k: usize)

Rotates the slice in-place such that the first self.len() - k elements of the slice move to the end while the last k elements move to the front.

After calling rotate_right, the element previously at index self.len() - k will become the first element in the slice.

Panics

This function will panic if k is greater than the length of the slice. Note that k == self.len() does not panic and is a no-op rotation.

Complexity

Takes linear (in self.len()) time.

Examples

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.rotate_right(2);
assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);

Rotating a subslice:

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a[1..5].rotate_right(1);
assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);

pub fn fill(&mut self, value: T)

where T: Clone,

Fills self with elements by cloning value.

Examples

let mut buf = vec![0; 10];
buf.fill(1);
assert_eq!(buf, vec![1; 10]);

pub fn fill_with<F>(&mut self, f: F)

where F: FnMut() -> T,

Fills self with elements returned by calling a closure repeatedly.

This method uses a closure to create new values. If you’d rather Clone a given value, use fill. If you want to use the Default trait to generate values, you can pass Default::default as the argument.

Examples

let mut buf = vec![1; 10];
buf.fill_with(Default::default);
assert_eq!(buf, vec![0; 10]);

pub fn clone_from_slice(&mut self, src: &[T])

where T: Clone,

Copies the elements from src into self.

The length of src must be the same as self.

Panics

This function will panic if the two slices have different lengths.

Examples

Cloning two elements from a slice into another:

let src = [1, 2, 3, 4];
let mut dst = [0, 0];

// Because the slices have to be the same length,
// we slice the source slice from four elements
// to two. It will panic if we don't do this.
dst.clone_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);

Rust enforces that there can only be one mutable reference with no immutable references to a particular piece of data in a particular scope. Because of this, attempting to use clone_from_slice on a single slice will result in a compile failure:

let mut slice = [1, 2, 3, 4, 5];

slice[..2].clone_from_slice(&slice[3..]); // compile fail!

To work around this, we can use split_at_mut to create two distinct sub-slices from a slice:

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.clone_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);

pub fn copy_from_slice(&mut self, src: &[T])

where T: Copy,

Copies all elements from src into self, using a memcpy.

The length of src must be the same as self.

If T does not implement Copy, use clone_from_slice.

Panics

This function will panic if the two slices have different lengths.

Examples

Copying two elements from a slice into another:

let src = [1, 2, 3, 4];
let mut dst = [0, 0];

// Because the slices have to be the same length,
// we slice the source slice from four elements
// to two. It will panic if we don't do this.
dst.copy_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);

Rust enforces that there can only be one mutable reference with no immutable references to a particular piece of data in a particular scope. Because of this, attempting to use copy_from_slice on a single slice will result in a compile failure:

let mut slice = [1, 2, 3, 4, 5];

slice[..2].copy_from_slice(&slice[3..]); // compile fail!

To work around this, we can use split_at_mut to create two distinct sub-slices from a slice:

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.copy_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);

pub fn copy_within<R>(&mut self, src: R, dest: usize)

where R: RangeBounds<usize>, T: Copy,

Copies elements from one part of the slice to another part of itself, using a memmove.

src is the range within self to copy from. dest is the starting index of the range within self to copy to, which will have the same length as src. The two ranges may overlap. The ends of the two ranges must be less than or equal to self.len().

Panics

This function will panic if either range exceeds the end of the slice, or if the end of src is before the start.

Examples

Copying four bytes within a slice:

let mut bytes = *b"Hello, World!";

bytes.copy_within(1..5, 8);

assert_eq!(&bytes, b"Hello, Wello!");

pub fn swap_with_slice(&mut self, other: &mut [T])

Swaps all elements in self with those in other.

The length of other must be the same as self.

Panics

This function will panic if the two slices have different lengths.

Example

Swapping two elements across slices:

let mut slice1 = [0, 0];
let mut slice2 = [1, 2, 3, 4];

slice1.swap_with_slice(&mut slice2[2..]);

assert_eq!(slice1, [3, 4]);
assert_eq!(slice2, [1, 2, 0, 0]);

Rust enforces that there can only be one mutable reference to a particular piece of data in a particular scope. Because of this, attempting to use swap_with_slice on a single slice will result in a compile failure:

let mut slice = [1, 2, 3, 4, 5];
slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!

To work around this, we can use split_at_mut to create two distinct mutable sub-slices from a slice:

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.swap_with_slice(&mut right[1..]);
}

assert_eq!(slice, [4, 5, 3, 1, 2]);

pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])

Transmutes the slice to a slice of another type, ensuring alignment of the types is maintained.

This method splits the slice into three distinct slices: prefix, correctly aligned middle slice of a new type, and the suffix slice. The middle part will be as big as possible under the given alignment constraint and element size.

This method has no purpose when either input element T or output element U are zero-sized and will return the original slice without splitting anything.

Safety

This method is essentially a transmute with respect to the elements in the returned middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

Examples

Basic usage:

unsafe {
    let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
    let (prefix, shorts, suffix) = bytes.align_to::<u16>();
    // less_efficient_algorithm_for_bytes(prefix);
    // more_efficient_algorithm_for_aligned_shorts(shorts);
    // less_efficient_algorithm_for_bytes(suffix);
}

pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])

Transmutes the mutable slice to a mutable slice of another type, ensuring alignment of the types is maintained.

This method splits the slice into three distinct slices: prefix, correctly aligned middle slice of a new type, and the suffix slice. The middle part will be as big as possible under the given alignment constraint and element size.

This method has no purpose when either input element T or output element U are zero-sized and will return the original slice without splitting anything.

Safety

This method is essentially a transmute with respect to the elements in the returned middle slice, so all the usual caveats pertaining to transmute::<T, U> also apply here.

Examples

Basic usage:

unsafe {
    let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
    let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>();
    // less_efficient_algorithm_for_bytes(prefix);
    // more_efficient_algorithm_for_aligned_shorts(shorts);
    // less_efficient_algorithm_for_bytes(suffix);
}

pub fn as_simd<const LANES: usize>(&self) -> (&[T], &[Simd<T, LANES>], &[T])

where Simd<T, LANES>: AsRef<[T; LANES]>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

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

Splits a slice into a prefix, a middle of aligned SIMD types, and a suffix.

This is a safe wrapper around slice::align_to, so inherits the same guarantees as that method.

Panics

This will panic if the size of the SIMD type is different from LANES times that of the scalar.

At the time of writing, the trait restrictions on Simd<T, LANES> keeps that from ever happening, as only power-of-two numbers of lanes are supported. It’s possible that, in the future, those restrictions might be lifted in a way that would make it possible to see panics from this method for something like LANES == 3.

Examples

#![feature(portable_simd)]
use core::simd::prelude::*;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // Not enough elements for anything in the middle

// They might be split in any possible way between prefix and suffix
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);

pub fn as_simd_mut<const LANES: usize>( &mut self, ) -> (&mut [T], &mut [Simd<T, LANES>], &mut [T])

where Simd<T, LANES>: AsMut<[T; LANES]>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

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

Splits a mutable slice into a mutable prefix, a middle of aligned SIMD types, and a mutable suffix.

This is a safe wrapper around slice::align_to_mut, so inherits the same guarantees as that method.

This is the mutable version of slice::as_simd; see that for examples.

Panics

This will panic if the size of the SIMD type is different from LANES times that of the scalar.

At the time of writing, the trait restrictions on Simd<T, LANES> keeps that from ever happening, as only power-of-two numbers of lanes are supported. It’s possible that, in the future, those restrictions might be lifted in a way that would make it possible to see panics from this method for something like LANES == 3.

pub fn is_sorted(&self) -> bool

where T: PartialOrd,

Checks if the elements of this slice are sorted.

That is, for each element a and its following element b, a <= b must hold. If the slice yields exactly zero or one element, true is returned.

Note that if Self::Item is only PartialOrd, but not Ord, the above definition implies that this function returns false if any two consecutive items are not comparable.

Examples

let empty: [i32; 0] = [];

assert!([1, 2, 2, 9].is_sorted());
assert!(![1, 3, 2, 4].is_sorted());
assert!([0].is_sorted());
assert!(empty.is_sorted());
assert!(![0.0, 1.0, f32::NAN].is_sorted());

pub fn is_sorted_by<'a, F>(&'a self, compare: F) -> bool

where F: FnMut(&'a T, &'a T) -> bool,

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

Instead of using PartialOrd::partial_cmp, this function uses the given compare function to determine whether two elements are to be considered in sorted order.

Examples

assert!([1, 2, 2, 9].is_sorted_by(|a, b| a <= b));
assert!(![1, 2, 2, 9].is_sorted_by(|a, b| a < b));

assert!([0].is_sorted_by(|a, b| true));
assert!([0].is_sorted_by(|a, b| false));

let empty: [i32; 0] = [];
assert!(empty.is_sorted_by(|a, b| false));
assert!(empty.is_sorted_by(|a, b| true));

pub fn is_sorted_by_key<'a, F, K>(&'a self, f: F) -> bool

where F: FnMut(&'a T) -> K, K: PartialOrd,

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

Instead of comparing the slice’s elements directly, this function compares the keys of the elements, as determined by f. Apart from that, it’s equivalent to is_sorted; see its documentation for more information.

Examples

assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));

pub fn partition_point<P>(&self, pred: P) -> usize

where P: FnMut(&T) -> bool,

Returns the index of the partition point according to the given predicate (the index of the first element of the second partition).

The slice is assumed to be partitioned according to the given predicate. This means that all elements for which the predicate returns true are at the start of the slice and all elements for which the predicate returns false are at the end. For example, [7, 15, 3, 5, 4, 12, 6] is partitioned under the predicate x % 2 != 0 (all odd numbers are at the start, all even at the end).

If this slice is not partitioned, the returned result is unspecified and meaningless, as this method performs a kind of binary search.

See also binary_search, binary_search_by, and binary_search_by_key.

Examples

let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);

assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));

If all elements of the slice match the predicate, including if the slice is empty, then the length of the slice will be returned:

let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);

If you want to insert an item to a sorted vector, while maintaining sort order:

let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x <= num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);

pub fn split_off<'a, R>(self: &mut &'a [T], range: R) -> Option<&'a [T]>

where R: OneSidedRange<usize>,

Removes the subslice corresponding to the given range and returns a reference to it.

Returns None and does not modify the slice if the given range is out of bounds.

Note that this method only accepts one-sided ranges such as 2.. or ..6, but not 2..6.

Examples

Splitting off the first three elements of a slice:

let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off(..3).unwrap();

assert_eq!(slice, &['d']);
assert_eq!(first_three, &['a', 'b', 'c']);

Splitting off a slice starting with the third element:

let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.split_off(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);

Getting None when range is out of bounds:

let mut slice: &[_] = &['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off(5..));
assert_eq!(None, slice.split_off(..5));
assert_eq!(None, slice.split_off(..=4));
let expected: &[char] = &['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off(..4));

pub fn split_off_mut<'a, R>( self: &mut &'a mut [T], range: R, ) -> Option<&'a mut [T]>

where R: OneSidedRange<usize>,

Removes the subslice corresponding to the given range and returns a mutable reference to it.

Returns None and does not modify the slice if the given range is out of bounds.

Note that this method only accepts one-sided ranges such as 2.. or ..6, but not 2..6.

Examples

Splitting off the first three elements of a slice:

let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut first_three = slice.split_off_mut(..3).unwrap();

assert_eq!(slice, &mut ['d']);
assert_eq!(first_three, &mut ['a', 'b', 'c']);

Splitting off a slice starting with the third element:

let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.split_off_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);

Getting None when range is out of bounds:

let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];

assert_eq!(None, slice.split_off_mut(5..));
assert_eq!(None, slice.split_off_mut(..5));
assert_eq!(None, slice.split_off_mut(..=4));
let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.split_off_mut(..4));

pub fn split_off_first<'a>(self: &mut &'a [T]) -> Option<&'a T>

Removes the first element of the slice and returns a reference to it.

Returns None if the slice is empty.

Examples

let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.split_off_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');

pub fn split_off_first_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>

Removes the first element of the slice and returns a mutable reference to it.

Returns None if the slice is empty.

Examples

let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.split_off_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');

pub fn split_off_last<'a>(self: &mut &'a [T]) -> Option<&'a T>

Removes the last element of the slice and returns a reference to it.

Returns None if the slice is empty.

Examples

let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.split_off_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');

pub fn split_off_last_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>

Removes the last element of the slice and returns a mutable reference to it.

Returns None if the slice is empty.

Examples

let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.split_off_last_mut().unwrap();
*last = 'd';

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'d');

pub unsafe fn get_disjoint_unchecked_mut<I, const N: usize>( &mut self, indices: [I; N], ) -> [&mut <I as SliceIndex<[T]>>::Output; N]

where I: GetDisjointMutIndex + SliceIndex<[T]>,

Returns mutable references to many indices at once, without doing any checks.

An index can be either a usize, a Range or a RangeInclusive. Note that this method takes an array, so all indices must be of the same type. If passed an array of usizes this method gives back an array of mutable references to single elements, while if passed an array of ranges it gives back an array of mutable references to slices.

For a safe alternative see get_disjoint_mut.

Safety

Calling this method with overlapping or out-of-bounds indices is undefined behavior even if the resulting references are not used.

Examples

let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0, 2]);
    *a *= 10;
    *b *= 100;
}
assert_eq!(x, &[10, 2, 400]);

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([0..1, 1..3]);
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(x, &[8, 88, 888]);

unsafe {
    let [a, b] = x.get_disjoint_unchecked_mut([1..=2, 0..=0]);
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(x, &[1, 11, 111]);

pub fn get_disjoint_mut<I, const N: usize>( &mut self, indices: [I; N], ) -> Result<[&mut <I as SliceIndex<[T]>>::Output; N], GetDisjointMutError>

where I: GetDisjointMutIndex + SliceIndex<[T]>,

Returns mutable references to many indices at once.

An index can be either a usize, a Range or a RangeInclusive. Note that this method takes an array, so all indices must be of the same type. If passed an array of usizes this method gives back an array of mutable references to single elements, while if passed an array of ranges it gives back an array of mutable references to slices.

Returns an error if any index is out-of-bounds, or if there are overlapping indices. An empty range is not considered to overlap if it is located at the beginning or at the end of another range, but is considered to overlap if it is located in the middle.

This method does a O(n^2) check to check that there are no overlapping indices, so be careful when passing many indices.

Examples

let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_disjoint_mut([0, 2]) {
    *a = 413;
    *b = 612;
}
assert_eq!(v, &[413, 2, 612]);

if let Ok([a, b]) = v.get_disjoint_mut([0..1, 1..3]) {
    a[0] = 8;
    b[0] = 88;
    b[1] = 888;
}
assert_eq!(v, &[8, 88, 888]);

if let Ok([a, b]) = v.get_disjoint_mut([1..=2, 0..=0]) {
    a[0] = 11;
    a[1] = 111;
    b[0] = 1;
}
assert_eq!(v, &[1, 11, 111]);

pub fn element_offset(&self, element: &T) -> Option<usize>

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

Returns the index that an element reference points to.

Returns None if element does not point to the start of an element within the slice.

This method is useful for extending slice iterators like slice::split.

Note that this uses pointer arithmetic and does not compare elements. To find the index of an element via comparison, use .iter().position() instead.

Panics

Panics if T is zero-sized.

Examples

Basic usage:

#![feature(substr_range)]

let nums: &[u32] = &[1, 7, 1, 1];
let num = &nums[2];

assert_eq!(num, &1);
assert_eq!(nums.element_offset(num), Some(2));

Returning None with an unaligned element:

#![feature(substr_range)]

let arr: &[[u32; 2]] = &[[0, 1], [2, 3]];
let flat_arr: &[u32] = arr.as_flattened();

let ok_elm: &[u32; 2] = flat_arr[0..2].try_into().unwrap();
let weird_elm: &[u32; 2] = flat_arr[1..3].try_into().unwrap();

assert_eq!(ok_elm, &[0, 1]);
assert_eq!(weird_elm, &[1, 2]);

assert_eq!(arr.element_offset(ok_elm), Some(0)); // Points to element 0
assert_eq!(arr.element_offset(weird_elm), None); // Points between element 0 and 1

pub fn subslice_range(&self, subslice: &[T]) -> Option<Range<usize>>

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

Returns the range of indices that a subslice points to.

Returns None if subslice does not point within the slice or if it is not aligned with the elements in the slice.

This method does not compare elements. Instead, this method finds the location in the slice that subslice was obtained from. To find the index of a subslice via comparison, instead use .windows().position().

This method is useful for extending slice iterators like slice::split.

Note that this may return a false positive (either Some(0..0) or Some(self.len()..self.len())) if subslice has a length of zero and points to the beginning or end of another, separate, slice.

Panics

Panics if T is zero-sized.

Examples

Basic usage:

#![feature(substr_range)]

let nums = &[0, 5, 10, 0, 0, 5];

let mut iter = nums
    .split(|t| *t == 0)
    .map(|n| nums.subslice_range(n).unwrap());

assert_eq!(iter.next(), Some(0..0));
assert_eq!(iter.next(), Some(1..3));
assert_eq!(iter.next(), Some(4..4));
assert_eq!(iter.next(), Some(5..6));

pub fn utf8_chunks(&self) -> Utf8Chunks<'_>

Creates an iterator over the contiguous valid UTF-8 ranges of this slice, and the non-UTF-8 fragments in between.

See the Utf8Chunk type for documentation of the items yielded by this iterator.

Examples

This function formats arbitrary but mostly-UTF-8 bytes into Rust source code in the form of a C-string literal (c"...").

use std::fmt::Write as _;

pub fn cstr_literal(bytes: &[u8]) -> String {
    let mut repr = String::new();
    repr.push_str("c\"");
    for chunk in bytes.utf8_chunks() {
        for ch in chunk.valid().chars() {
            // Escapes \0, \t, \r, \n, \\, \', \", and uses \u{...} for non-printable characters.
            write!(repr, "{}", ch.escape_debug()).unwrap();
        }
        for byte in chunk.invalid() {
            write!(repr, "\\x{:02X}", byte).unwrap();
        }
    }
    repr.push('"');
    repr
}

fn main() {
    let lit = cstr_literal(b"\xferris the \xf0\x9f\xa6\x80\x07");
    let expected = stringify!(c"\xFErris the 🦀\u{7}");
    assert_eq!(lit, expected);
}

pub fn sort(&mut self)

where T: Ord,

Sorts the slice in ascending order, preserving initial order of equal elements.

This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.

If the implementation of Ord for T does not implement a total order, the function may panic; even if the function exits normally, the resulting order of elements in the slice is unspecified. See also the note on panicking below.

When applicable, unstable sorting is preferred because it is generally faster than stable sorting and it doesn’t allocate auxiliary memory. See sort_unstable. The exception are partially sorted slices, which may be better served with slice::sort.

Sorting types that only implement PartialOrd such as f32 and f64 require additional precautions. For example, f32::NAN != f32::NAN, which doesn’t fulfill the reflexivity requirement of Ord. By using an alternative comparison function with slice::sort_by such as f32::total_cmp or f64::total_cmp that defines a total order users can sort slices containing floating-point values. Alternatively, if all values in the slice are guaranteed to be in a subset for which PartialOrd::partial_cmp forms a total order, it’s possible to sort the slice with sort_by(|a, b| a.partial_cmp(b).unwrap()).

Current implementation

The current implementation is based on driftsort by Orson Peters and Lukas Bergdoll, which combines the fast average case of quicksort with the fast worst case and partial run detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the expected time to sort the data is O(n * log(k)).

The auxiliary memory allocation behavior depends on the input length. Short slices are handled without allocation, medium sized slices allocate self.len() and beyond that it clamps at self.len() / 2.

Panics

May panic if the implementation of Ord for T does not implement a total order, or if the Ord implementation itself panics.

All safe functions on slices preserve the invariant that even if the function panics, all original elements will remain in the slice and any possible modifications via interior mutability are observed in the input. This ensures that recovery code (for instance inside of a Drop or following a catch_unwind) will still have access to all the original elements. For instance, if the slice belongs to a Vec, the Vec::drop method will be able to dispose of all contained elements.

Examples

let mut v = [4, -5, 1, -3, 2];

v.sort();
assert_eq!(v, [-5, -3, 1, 2, 4]);

pub fn sort_by<F>(&mut self, compare: F)

where F: FnMut(&T, &T) -> Ordering,

Sorts the slice in ascending order with a comparison function, preserving initial order of equal elements.

This sort is stable (i.e., does not reorder equal elements) and O(n * log(n)) worst-case.

If the comparison function compare does not implement a total order, the function may panic; even if the function exits normally, the resulting order of elements in the slice is unspecified. See also the note on panicking below.

For example |a, b| (a - b).cmp(a) is a comparison function that is neither transitive nor reflexive nor total, a < b < c < a with a = 1, b = 2, c = 3. For more information and examples see the Ord documentation.

Current implementation

The current implementation is based on driftsort by Orson Peters and Lukas Bergdoll, which combines the fast average case of quicksort with the fast worst case and partial run detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the expected time to sort the data is O(n * log(k)).

The auxiliary memory allocation behavior depends on the input length. Short slices are handled without allocation, medium sized slices allocate self.len() and beyond that it clamps at self.len() / 2.

Panics

May panic if compare does not implement a total order, or if compare itself panics.

All safe functions on slices preserve the invariant that even if the function panics, all original elements will remain in the slice and any possible modifications via interior mutability are observed in the input. This ensures that recovery code (for instance inside of a Drop or following a catch_unwind) will still have access to all the original elements. For instance, if the slice belongs to a Vec, the Vec::drop method will be able to dispose of all contained elements.

Examples

let mut v = [4, -5, 1, -3, 2];
v.sort_by(|a, b| a.cmp(b));
assert_eq!(v, [-5, -3, 1, 2, 4]);

// reverse sorting
v.sort_by(|a, b| b.cmp(a));
assert_eq!(v, [4, 2, 1, -3, -5]);

pub fn sort_by_key<K, F>(&mut self, f: F)

where F: FnMut(&T) -> K, K: Ord,

Sorts the slice in ascending order with a key extraction function, preserving initial order of equal elements.

This sort is stable (i.e., does not reorder equal elements) and O(m * n * log(n)) worst-case, where the key function is O(m).

If the implementation of Ord for K does not implement a total order, the function may panic; even if the function exits normally, the resulting order of elements in the slice is unspecified. See also the note on panicking below.

Current implementation

The current implementation is based on driftsort by Orson Peters and Lukas Bergdoll, which combines the fast average case of quicksort with the fast worst case and partial run detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the expected time to sort the data is O(n * log(k)).

The auxiliary memory allocation behavior depends on the input length. Short slices are handled without allocation, medium sized slices allocate self.len() and beyond that it clamps at self.len() / 2.

Panics

May panic if the implementation of Ord for K does not implement a total order, or if the Ord implementation or the key-function f panics.

All safe functions on slices preserve the invariant that even if the function panics, all original elements will remain in the slice and any possible modifications via interior mutability are observed in the input. This ensures that recovery code (for instance inside of a Drop or following a catch_unwind) will still have access to all the original elements. For instance, if the slice belongs to a Vec, the Vec::drop method will be able to dispose of all contained elements.

Examples

let mut v = [4i32, -5, 1, -3, 2];

v.sort_by_key(|k| k.abs());
assert_eq!(v, [1, 2, -3, 4, -5]);

pub fn sort_by_cached_key<K, F>(&mut self, f: F)

where F: FnMut(&T) -> K, K: Ord,

Sorts the slice in ascending order with a key extraction function, preserving initial order of equal elements.

This sort is stable (i.e., does not reorder equal elements) and O(m * n + n * log(n)) worst-case, where the key function is O(m).

During sorting, the key function is called at most once per element, by using temporary storage to remember the results of key evaluation. The order of calls to the key function is unspecified and may change in future versions of the standard library.

If the implementation of Ord for K does not implement a total order, the function may panic; even if the function exits normally, the resulting order of elements in the slice is unspecified. See also the note on panicking below.

For simple key functions (e.g., functions that are property accesses or basic operations), sort_by_key is likely to be faster.

Current implementation

The current implementation is based on instruction-parallel-network sort by Lukas Bergdoll, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on fully sorted and reversed inputs. And O(k * log(n)) where k is the number of distinct elements in the input. It leverages superscalar out-of-order execution capabilities commonly found in CPUs, to efficiently perform the operation.

In the worst case, the algorithm allocates temporary storage in a Vec<(K, usize)> the length of the slice.

Panics

May panic if the implementation of Ord for K does not implement a total order, or if the Ord implementation panics.

All safe functions on slices preserve the invariant that even if the function panics, all original elements will remain in the slice and any possible modifications via interior mutability are observed in the input. This ensures that recovery code (for instance inside of a Drop or following a catch_unwind) will still have access to all the original elements. For instance, if the slice belongs to a Vec, the Vec::drop method will be able to dispose of all contained elements.

Examples

let mut v = [4i32, -5, 1, -3, 2, 10];

// Strings are sorted by lexicographical order.
v.sort_by_cached_key(|k| k.to_string());
assert_eq!(v, [-3, -5, 1, 10, 2, 4]);

pub fn to_vec(&self) -> Vec<T>

where T: Clone,

Copies self into a new Vec.

Examples

let s = [10, 40, 30];
let x = s.to_vec();
// Here, `s` and `x` can be modified independently.

pub fn to_vec_in<A>(&self, alloc: A) -> Vec<T, A>

where A: Allocator, T: Clone,

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

Copies self into a new Vec with an allocator.

Examples

#![feature(allocator_api)]

use std::alloc::System;

let s = [10, 40, 30];
let x = s.to_vec_in(System);
// Here, `s` and `x` can be modified independently.

pub fn repeat(&self, n: usize) -> Vec<T>

where T: Copy,

Creates a vector by copying a slice n times.

Panics

This function will panic if the capacity would overflow.

Examples

assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);

A panic upon overflow:

// this will panic at runtime
b"0123456789abcdef".repeat(usize::MAX);

pub fn concat<Item>(&self) -> <[T] as Concat<Item>>::Output

where [T]: Concat<Item>, Item: ?Sized,

Flattens a slice of T into a single value Self::Output.

Examples

assert_eq!(["hello", "world"].concat(), "helloworld");
assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);

pub fn join<Separator>( &self, sep: Separator, ) -> <[T] as Join<Separator>>::Output

where [T]: Join<Separator>,

Flattens a slice of T into a single value Self::Output, placing a given separator between each.

Examples

assert_eq!(["hello", "world"].join(" "), "hello world");
assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]);

pub fn connect<Separator>( &self, sep: Separator, ) -> <[T] as Join<Separator>>::Output

where [T]: Join<Separator>,

👎Deprecated since 1.3.0: renamed to join

Flattens a slice of T into a single value Self::Output, placing a given separator between each.

Examples

assert_eq!(["hello", "world"].connect(" "), "hello world");
assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);

pub fn to_ascii_uppercase(&self) -> Vec<u8>

Returns a vector containing a copy of this slice where each byte is mapped to its ASCII upper case equivalent.

ASCII letters ‘a’ to ‘z’ are mapped to ‘A’ to ‘Z’, but non-ASCII letters are unchanged.

To uppercase the value in-place, use make_ascii_uppercase.

pub fn to_ascii_lowercase(&self) -> Vec<u8>

Returns a vector containing a copy of this slice where each byte is mapped to its ASCII lower case equivalent.

ASCII letters ‘A’ to ‘Z’ are mapped to ‘a’ to ‘z’, but non-ASCII letters are unchanged.

To lowercase the value in-place, use make_ascii_lowercase.

Trait Implementations

impl<N> AsRef<RCHandle<N>> for RCHandle<N>

where N: NativeRefCounted,

fn as_ref(&self) -> &RCHandle<N>

Converts this type into a shared reference of the (usually inferred) input type.

impl<N> Clone for RCHandle<N>

where N: NativeRefCounted,

fn clone(&self) -> RCHandle<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H> ConditionallySend for RCHandle<H>

where H: NativeRefCountedBase,

RCHandle<H> is conditionally Send and can be sent to another thread when its reference count is 1.

fn can_send(&self) -> bool

Returns true if the handle can be sent to another thread.

fn wrap_send(self) -> Result<Sendable<RCHandle<H>>, RCHandle<H>>

Wrap the handle in a type that can be sent to another thread and unwrapped there.

impl Debug for RCHandle<GrDirectContext>

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

Formats the value using the given formatter.

impl Debug for RCHandle<GrGLInterface>

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

Formats the value using the given formatter.

impl Debug for RCHandle<GrRecordingContext>

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

Formats the value using the given formatter.

impl<N> Debug for RCHandle<N>

where N: NativeRefCounted, RCHandle<N>: DebugAttributes,

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkBlender>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkColorFilter>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkColorSpace>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkColorTable>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkContourMeasure>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkData>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkDataTable>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkDrawable>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkFontMgr>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkFontStyleSet>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkImage>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkImageFilter>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkMaskFilter>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkOrderedFontMgr>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkPathEffect>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkPicture>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkPixelRef>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkRuntimeEffect>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkSVGDOM>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkShader>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkSurface>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkTextBlob>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkTypeface>

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

Formats the value using the given formatter.

impl Debug for RCHandle<SkVertices>

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

Formats the value using the given formatter.

impl Debug for RCHandle<skgpu_MutableTextureState>

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

Formats the value using the given formatter.

impl Debug for RCHandle<skia_textlayout_FontCollection>

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

Formats the value using the given formatter.

impl Debug for RCHandle<skia_textlayout_TypefaceFontProvider>

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

Formats the value using the given formatter.

impl Debug for RCHandle<skia_textlayout_TypefaceFontStyleSet>

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

Formats the value using the given formatter.

impl DebugAttributes for RCHandle<SkSVGCircle>

const NAME: &'static str = "Circle"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGClipPath>

const NAME: &'static str = "ClipPath"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGContainer>

const NAME: &'static str = "Container"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGDefs>

const NAME: &'static str = "Defs"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGEllipse>

const NAME: &'static str = "Ellipse"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFe>

const NAME: &'static str = "Fe"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeBlend>

const NAME: &'static str = "FeBlend"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeColorMatrix>

const NAME: &'static str = "FeColorMatrix"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeComponentTransfer>

const NAME: &'static str = "FeComponentTransfer"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeComposite>

const NAME: &'static str = "FeComposite"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeDiffuseLighting>

const NAME: &'static str = "FeDiffuseLighting"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeDisplacementMap>

const NAME: &'static str = "FeDisplacementMap"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeDistantLight>

const NAME: &'static str = "FeDistantLight"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeFlood>

const NAME: &'static str = "FeFlood"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeFunc>

const NAME: &'static str = "FeFunc"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeGaussianBlur>

const NAME: &'static str = "FeGaussianBlur"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeImage>

const NAME: &'static str = "FeImage"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeLighting>

const NAME: &'static str = "FeLighting"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeMerge>

const NAME: &'static str = "FeMerge"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeMergeNode>

const NAME: &'static str = "FeMergeNode"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeMorphology>

const NAME: &'static str = "FeMorphology"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeOffset>

const NAME: &'static str = "FeOffset"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFePointLight>

const NAME: &'static str = "FePointLight"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeSpecularLighting>

const NAME: &'static str = "FeSpecularLighting"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeSpotLight>

const NAME: &'static str = "FeSpotLight"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFeTurbulence>

const NAME: &'static str = "FeTurbulence"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGFilter>

const NAME: &'static str = "Filter"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGG>

const NAME: &'static str = "G"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGGradient>

const NAME: &'static str = "Gradient"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGImage>

const NAME: &'static str = "Image"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGLine>

const NAME: &'static str = "Line"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGLinearGradient>

const NAME: &'static str = "LinearGradient"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGMask>

const NAME: &'static str = "Mask"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGNode>

const NAME: &'static str = "Node"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGPath>

const NAME: &'static str = "Path"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGPattern>

const NAME: &'static str = "Pattern"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGPoly>

const NAME: &'static str = "Poly"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGRadialGradient>

const NAME: &'static str = "RadialGradient"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGRect>

const NAME: &'static str = "Rect"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGSVG>

const NAME: &'static str = "Svg"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGShape>

const NAME: &'static str = "Shape"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGStop>

const NAME: &'static str = "Stop"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGTSpan>

const NAME: &'static str = "TSpan"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGText>

const NAME: &'static str = "Text"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGTextContainer>

const NAME: &'static str = "TextContainer"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGTextLiteral>

const NAME: &'static str = "TextLiteral"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGTextPath>

const NAME: &'static str = "TextPath"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGTransformableNode>

const NAME: &'static str = "TransformableNode"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl DebugAttributes for RCHandle<SkSVGUse>

const NAME: &'static str = "Use"

fn _dbg(&self, builder: &mut DebugStruct<'_, '_>)

impl Default for RCHandle<SkFontMgr>

fn default() -> RCHandle<SkFontMgr>

Returns the “default value” for a type.

impl Default for RCHandle<SkFontStyleSet>

fn default() -> RCHandle<SkFontStyleSet>

Returns the “default value” for a type.

impl Default for RCHandle<SkOrderedFontMgr>

fn default() -> RCHandle<SkOrderedFontMgr>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGCircle>

fn default() -> RCHandle<SkSVGCircle>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGClipPath>

fn default() -> RCHandle<SkSVGClipPath>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGDefs>

fn default() -> RCHandle<SkSVGDefs>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGEllipse>

fn default() -> RCHandle<SkSVGEllipse>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeBlend>

fn default() -> RCHandle<SkSVGFeBlend>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeColorMatrix>

fn default() -> RCHandle<SkSVGFeColorMatrix>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeComponentTransfer>

fn default() -> RCHandle<SkSVGFeComponentTransfer>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeComposite>

fn default() -> RCHandle<SkSVGFeComposite>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeDiffuseLighting>

fn default() -> RCHandle<SkSVGFeDiffuseLighting>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeDisplacementMap>

fn default() -> RCHandle<SkSVGFeDisplacementMap>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeDistantLight>

fn default() -> RCHandle<SkSVGFeDistantLight>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeFlood>

fn default() -> RCHandle<SkSVGFeFlood>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeGaussianBlur>

fn default() -> RCHandle<SkSVGFeGaussianBlur>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeImage>

fn default() -> RCHandle<SkSVGFeImage>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeMerge>

fn default() -> RCHandle<SkSVGFeMerge>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeMergeNode>

fn default() -> RCHandle<SkSVGFeMergeNode>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeMorphology>

fn default() -> RCHandle<SkSVGFeMorphology>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeOffset>

fn default() -> RCHandle<SkSVGFeOffset>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFePointLight>

fn default() -> RCHandle<SkSVGFePointLight>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeSpecularLighting>

fn default() -> RCHandle<SkSVGFeSpecularLighting>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeSpotLight>

fn default() -> RCHandle<SkSVGFeSpotLight>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFeTurbulence>

fn default() -> RCHandle<SkSVGFeTurbulence>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGFilter>

fn default() -> RCHandle<SkSVGFilter>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGG>

fn default() -> RCHandle<SkSVGG>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGImage>

fn default() -> RCHandle<SkSVGImage>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGLine>

fn default() -> RCHandle<SkSVGLine>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGLinearGradient>

fn default() -> RCHandle<SkSVGLinearGradient>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGMask>

fn default() -> RCHandle<SkSVGMask>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGPath>

fn default() -> RCHandle<SkSVGPath>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGPattern>

fn default() -> RCHandle<SkSVGPattern>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGRadialGradient>

fn default() -> RCHandle<SkSVGRadialGradient>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGRect>

fn default() -> RCHandle<SkSVGRect>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGSVG>

fn default() -> RCHandle<SkSVGSVG>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGStop>

fn default() -> RCHandle<SkSVGStop>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGTSpan>

fn default() -> RCHandle<SkSVGTSpan>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGText>

fn default() -> RCHandle<SkSVGText>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGTextLiteral>

fn default() -> RCHandle<SkSVGTextLiteral>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGTextPath>

fn default() -> RCHandle<SkSVGTextPath>

Returns the “default value” for a type.

impl Default for RCHandle<SkSVGUse>

fn default() -> RCHandle<SkSVGUse>

Returns the “default value” for a type.

impl Default for RCHandle<SkShader>

fn default() -> RCHandle<SkShader>

Returns the “default value” for a type.

impl Default for RCHandle<skgpu_MutableTextureState>

fn default() -> RCHandle<skgpu_MutableTextureState>

Returns the “default value” for a type.

impl Default for RCHandle<skia_textlayout_TypefaceFontProvider>

fn default() -> RCHandle<skia_textlayout_TypefaceFontProvider>

Returns the “default value” for a type.

impl Deref for RCHandle<GrDirectContext>

type Target = RCHandle<GrRecordingContext>

The resulting type after dereferencing.

fn deref(&self) -> &<RCHandle<GrDirectContext> as Deref>::Target

Dereferences the value.

impl Deref for RCHandle<SkData>

type Target = [u8]

The resulting type after dereferencing.

fn deref(&self) -> &<RCHandle<SkData> as Deref>::Target

Dereferences the value.

impl Deref for RCHandle<SkOrderedFontMgr>

type Target = RCHandle<SkFontMgr>

The resulting type after dereferencing.

fn deref(&self) -> &<RCHandle<SkOrderedFontMgr> as Deref>::Target

Dereferences the value.

impl<T> Deref for RCHandle<T>

where T: NativeRefCounted + NodeSubtype,

type Target = RCHandle<<T as NodeSubtype>::Base>

The resulting type after dereferencing.

fn deref(&self) -> &<RCHandle<T> as Deref>::Target

Dereferences the value.

impl Deref for RCHandle<skia_textlayout_TypefaceFontProvider>

type Target = RCHandle<SkFontMgr>

The resulting type after dereferencing.

fn deref( &self, ) -> &<RCHandle<skia_textlayout_TypefaceFontProvider> as Deref>::Target

Dereferences the value.

impl Deref for RCHandle<skia_textlayout_TypefaceFontStyleSet>

type Target = RCHandle<SkFontStyleSet>

The resulting type after dereferencing.

fn deref( &self, ) -> &<RCHandle<skia_textlayout_TypefaceFontStyleSet> as Deref>::Target

Dereferences the value.

impl DerefMut for RCHandle<GrDirectContext>

fn deref_mut(&mut self) -> &mut <RCHandle<GrDirectContext> as Deref>::Target

Mutably dereferences the value.

impl DerefMut for RCHandle<SkOrderedFontMgr>

fn deref_mut(&mut self) -> &mut <RCHandle<SkOrderedFontMgr> as Deref>::Target

Mutably dereferences the value.

impl<T> DerefMut for RCHandle<T>

where T: NativeRefCounted + NodeSubtype,

This implementation of DerefMut causes subsequent UB when the containing RCHandle gets overwritten by a base type that does not match the actual underlying type.

fn deref_mut(&mut self) -> &mut <RCHandle<T> as Deref>::Target

Mutably dereferences the value.

impl DerefMut for RCHandle<skia_textlayout_TypefaceFontProvider>

fn deref_mut( &mut self, ) -> &mut <RCHandle<skia_textlayout_TypefaceFontProvider> as Deref>::Target

Mutably dereferences the value.

impl DerefMut for RCHandle<skia_textlayout_TypefaceFontStyleSet>

fn deref_mut( &mut self, ) -> &mut <RCHandle<skia_textlayout_TypefaceFontStyleSet> as Deref>::Target

Mutably dereferences the value.

impl<N> Drop for RCHandle<N>

where N: NativeRefCounted,

fn drop(&mut self)

Executes the destructor for this type.

impl<N> Flattenable for RCHandle<N>

where N: NativeFlattenable + NativeRefCountedBase,

fn type_name(&self) -> &CStr

fn serialize(&self) -> RCHandle<SkData>

fn deserialize(data: &[u8]) -> Option<RCHandle<N>>

impl<N> From<&RCHandle<N>> for RCHandle<N>

where N: NativeRefCounted,

A reference counted handle is cheap to clone, so we do support a conversion from a reference to a ref counter to an owned handle.

fn from(rch: &RCHandle<N>) -> RCHandle<N>

Converts to this type from the input type.

impl From<SkBlendMode> for RCHandle<SkBlender>

fn from(mode: SkBlendMode) -> RCHandle<SkBlender>

Converts to this type from the input type.

impl From<Box<dyn ResourceProvider>> for RCHandle<RustResourceProvider>

fn from( resource_provider: Box<dyn ResourceProvider>, ) -> RCHandle<RustResourceProvider>

Converts to this type from the input type.

impl From<RCHandle<GrDirectContext>> for RCHandle<GrRecordingContext>

fn from( direct_context: RCHandle<GrDirectContext>, ) -> RCHandle<GrRecordingContext>

Converts to this type from the input type.

impl From<RCHandle<SkBlender>> for ChildPtr

fn from(blender: RCHandle<SkBlender>) -> ChildPtr

Converts to this type from the input type.

impl From<RCHandle<SkColorFilter>> for ChildPtr

fn from(color_filter: RCHandle<SkColorFilter>) -> ChildPtr

Converts to this type from the input type.

impl From<RCHandle<SkFontMgr>> for RCHandle<RustResourceProvider>

Support a direct conversion from a FontMgr into a local native resource provider.

fn from(font_mgr: RCHandle<SkFontMgr>) -> RCHandle<RustResourceProvider>

Converts to this type from the input type.

impl From<RCHandle<SkOrderedFontMgr>> for RCHandle<SkFontMgr>

fn from(font_mgr: RCHandle<SkOrderedFontMgr>) -> RCHandle<SkFontMgr>

Converts to this type from the input type.

impl From<RCHandle<SkSVGNode>> for TypedNode

fn from(node: RCHandle<SkSVGNode>) -> TypedNode

Converts to this type from the input type.

impl From<RCHandle<SkShader>> for ChildPtr

fn from(shader: RCHandle<SkShader>) -> ChildPtr

Converts to this type from the input type.

impl From<RCHandle<skia_textlayout_TypefaceFontProvider>> for RCHandle<SkFontMgr>

fn from( provider: RCHandle<skia_textlayout_TypefaceFontProvider>, ) -> RCHandle<SkFontMgr>

Converts to this type from the input type.

impl<T> From<T> for RCHandle<RustResourceProvider>

where T: ResourceProvider + 'static,

fn from(value: T) -> RCHandle<RustResourceProvider>

Converts to this type from the input type.

impl From<TypedNode> for RCHandle<SkSVGNode>

fn from(value: TypedNode) -> RCHandle<SkSVGNode>

Converts to this type from the input type.

impl Index<usize> for RCHandle<SkDataTable>

type Output = [u8]

The returned type after indexing.

fn index( &self, index: usize, ) -> &<RCHandle<SkDataTable> as Index<usize>>::Output

Performs the indexing (container[index]) operation.

impl<N> PartialEq for RCHandle<N>

where N: NativeRefCounted + NativePartialEq,

fn eq(&self, rhs: &RCHandle<N>) -> 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 PartialEq for RCHandle<SkData>

fn eq(&self, other: &RCHandle<SkData>) -> 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<N> PointerWrapper<N> for RCHandle<N>

where N: NativeRefCounted,

fn wrap(ptr: *mut N) -> Option<RCHandle<N>>

Wraps a native pointer into a wrapper type. Returns None if the pointer is null.

fn unwrap(self) -> *mut N

Unwraps the wrapper type into the native pointer.

fn inner(&self) -> &N

Access the wrapped pointer.

fn inner_mut(&mut self) -> &mut N

Access the wrapped pointer.

impl Send for RCHandle<SkBlender>

impl Send for RCHandle<SkColorFilter>

impl Send for RCHandle<SkColorSpace>

impl Send for RCHandle<SkColorTable>

impl Send for RCHandle<SkContourMeasure>

impl Send for RCHandle<SkData>

impl Send for RCHandle<SkDataTable>

impl Send for RCHandle<SkImage>

impl Send for RCHandle<SkImageFilter>

impl Send for RCHandle<SkMaskFilter>

impl Send for RCHandle<SkPathEffect>

impl Send for RCHandle<SkPicture>

impl Send for RCHandle<SkPixelRef>

impl Send for RCHandle<SkShader>

impl Send for RCHandle<SkTextBlob>

impl Send for RCHandle<SkTypeface>

impl Send for RCHandle<SkVertices>

impl Send for RCHandle<skgpu_MutableTextureState>

impl Sync for RCHandle<SkBlender>

impl Sync for RCHandle<SkColorFilter>

impl Sync for RCHandle<SkColorSpace>

impl Sync for RCHandle<SkColorTable>

impl Sync for RCHandle<SkContourMeasure>

impl Sync for RCHandle<SkData>

impl Sync for RCHandle<SkDataTable>

impl Sync for RCHandle<SkImage>

impl Sync for RCHandle<SkImageFilter>

impl Sync for RCHandle<SkMaskFilter>

impl Sync for RCHandle<SkPathEffect>

impl Sync for RCHandle<SkPicture>

impl Sync for RCHandle<SkPixelRef>

impl Sync for RCHandle<SkShader>

impl Sync for RCHandle<SkTextBlob>

impl Sync for RCHandle<SkTypeface>

impl Sync for RCHandle<SkVertices>

impl Sync for RCHandle<skgpu_MutableTextureState>