Struct exr::image::recursive::NoneMore

pub struct NoneMore;

No more recursion. Can be used within any Recursive<NoneMore, YourValue> type.

Trait Implementations

impl CheckDuplicates for NoneMore

fn already_contains(&self, _: &Text) -> bool

Check for duplicate channel names.

impl Clone for NoneMore

fn clone(&self) -> NoneMore

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NoneMore

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

Formats the value using the given formatter.

impl Default for NoneMore

fn default() -> NoneMore

Returns the “default value” for a type.

impl IntoNonRecursive for NoneMore

type NonRecursive = ()

The resulting tuple type.

fn into_non_recursive(self) -> Self::NonRecursive

Convert this recursive type to a nice tuple.

impl IntoRecursive for NoneMore

type Recursive = NoneMore

The recursive type resulting from this tuple.

fn into_recursive(self) -> Self::Recursive

Create a recursive type from this tuple.

impl LayersWriter for NoneMore

fn extract_uncompressed_block(&self, _: &[Header], _: BlockIndex) -> Vec<u8>

Deliver a block of pixels from a single layer to be stored in the file

impl PartialEq<NoneMore> for NoneMore

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl ReadSpecificChannel for NoneMore

type RecursivePixelReader = NoneMore

A separate internal reader for the pixels. Will be of type Recursive<_, SampleReader<_>>, depending on the pixels of the specific channel combination.

fn create_recursive_reader(
    &self,
    _: &ChannelList
) -> Result<Self::RecursivePixelReader>

Create a separate internal reader for the pixels of the specific channel combination.

fn required<Sample>(
    self,
    channel_name: impl Into<Text>
) -> ReadRequiredChannel<Self, Sample>

Plan to read an additional channel from the image, with the specified name. If the channel cannot be found in the image when the image is read, the image will not be loaded. The generic parameter can usually be inferred from the closure in collect_pixels.

fn optional<Sample>(
    self,
    channel_name: impl Into<Text>,
    default_sample: Sample
) -> ReadOptionalChannel<Self, Sample>

Plan to read an additional channel from the image, with the specified name. If the file does not contain this channel, the specified default sample will be returned instead. You can check whether the channel has been loaded by checking the presence of the optional channel description before instantiating your own image. The generic parameter can usually be inferred from the closure in collect_pixels.

fn collect_pixels<Pixel, PixelStorage, CreatePixels, SetPixel>(
    self,
    create_pixels: CreatePixels,
    set_pixel: SetPixel
) -> CollectPixels<Self, Pixel, PixelStorage, CreatePixels, SetPixel> where
    <Self::RecursivePixelReader as RecursivePixelReader>::RecursivePixel: IntoTuple<Pixel>,
    <Self::RecursivePixelReader as RecursivePixelReader>::RecursiveChannelDescriptions: IntoNonRecursive,
    CreatePixels: Fn(Vec2<usize>, &<<Self::RecursivePixelReader as RecursivePixelReader>::RecursiveChannelDescriptions as IntoNonRecursive>::NonRecursive) -> PixelStorage,
    SetPixel: Fn(&mut PixelStorage, Vec2<usize>, Pixel), 

Using two closures, define how to store the pixels. The first closure creates an image, and the second closure inserts a single pixel. The type of the pixel can be defined by the second closure; it must be a tuple containing f16, f32, u32 or Sample values. See the examples for more information.

impl RecursivePixelReader for NoneMore

type RecursiveChannelDescriptions = NoneMore

The channel descriptions from the image. Will be converted to a tuple before being stored in SpecificChannels<_, ChannelDescriptions>.

fn get_descriptions(&self) -> Self::RecursiveChannelDescriptions

Returns the channel descriptions based on the channels in the file.

type RecursivePixel = NoneMore

The pixel type. Will be converted to a tuple at the end of the process.

fn read_pixels<'s, FullPixel>(
    &self,
    _: &'s [u8],
    _: &mut [FullPixel],
    _: impl Fn(&mut FullPixel) -> &mut NoneMore
)

Read the line of pixels.

impl RecursivePixelWriter<NoneMore> for NoneMore

fn write_pixels<FullPixel>(
    &self,
    _: &mut [u8],
    _: &[FullPixel],
    _: impl Fn(&FullPixel) -> &NoneMore
)

Write pixels to a slice of bytes. Recursively do this for all channels.

impl ValidateResult for NoneMore

fn validate_result(
    &self,
    _: &Self,
    _: ValidationOptions,
    _: String
) -> ValidationResult

Compare self with the other. Exceptional behaviour:

fn assert_equals_result(&self, result: &Self)

Compare self with the other. Panics if not equal.

impl WritableChannelsDescription<NoneMore> for NoneMore

type RecursiveWriter = NoneMore

A type that has a recursive entry for each channel in the image, which must accept the desired pixel type.

fn create_recursive_writer(&self, _: &ChannelList) -> Self::RecursiveWriter

Create the temporary writer, accepting the sorted list of channels from channel_descriptions_list.

fn channel_descriptions_list(&self) -> SmallVec<[ChannelDescription; 5]>

Return all the channels that should actually end up in the image, in any order.

impl<'slf> WritableLayers<'slf> for NoneMore

fn infer_headers(&self, _: &ImageAttributes) -> Headers

Generate the file meta data for this list of layers

type Writer = NoneMore

The type of temporary writer

fn create_writer(&'slf self, _: &[Header]) -> Self::Writer

Create a temporary writer for this list of layers

impl Copy for NoneMore

impl Eq for NoneMore

impl StructuralEq for NoneMore

impl StructuralPartialEq for NoneMore