Enum exr::meta::attribute::AttributeValue

pub enum AttributeValue {
    ChannelList(ChannelList),
    Chromaticities(Chromaticities),
    Compression(Compression),
    EnvironmentMap(EnvironmentMap),
    KeyCode(KeyCode),
    LineOrder(LineOrder),
    Matrix3x3(Matrix3x3),
    Matrix4x4(Matrix4x4),
    Preview(Preview),
    Rational(Rational),
    BlockType(BlockType),
    TextVector(Vec<Text>),
    TileDescription(TileDescription),
    TimeCode(TimeCode),
    Text(Text),
    F64(f64),
    F32(f32),
    I32(i32),
    IntegerBounds(IntegerBounds),
    FloatRect(FloatRect),
    IntVec2(Vec2<i32>),
    FloatVec2(Vec2<f32>),
    IntVec3((i32, i32, i32)),
    FloatVec3((f32, f32, f32)),
    Custom {
        kind: Text,
        bytes: Vec<u8>,
    },
}

Contains one of all possible attributes. Includes a variant for custom attributes.

Variants

ChannelList(ChannelList)

Channel meta data.

Chromaticities(Chromaticities)

Color space definition.

Compression(Compression)

Compression method of this layer.

EnvironmentMap(EnvironmentMap)

This image is an environment map.

KeyCode(KeyCode)

Film roll information.

LineOrder(LineOrder)

Order of the bocks in the file.

Matrix3x3(Matrix3x3)

A 3x3 matrix of floats.

Matrix4x4(Matrix4x4)

A 4x4 matrix of floats.

Preview(Preview)

8-bit rgba Preview of the image.

Rational(Rational)

An integer dividend and divisor.

BlockType(BlockType)

Deep or flat and tiled or scan line.

TextVector(Vec<Text>)

List of texts.

TileDescription(TileDescription)

How to tile up the image.

TimeCode(TimeCode)

Timepoint and more.

Text(Text)

A string of byte-chars.

F64(f64)

64-bit float

F32(f32)

32-bit float

I32(i32)

32-bit signed integer

IntegerBounds(IntegerBounds)

2D integer rectangle.

FloatRect(FloatRect)

2D float rectangle.

IntVec2(Vec2<i32>)

2D integer vector.

FloatVec2(Vec2<f32>)

2D float vector.

IntVec3((i32, i32, i32))

3D integer vector.

FloatVec3((f32, f32, f32))

3D float vector.

Custom

Fields

kind: Text

The name of the type this attribute is an instance of.

bytes: Vec<u8>

The value, stored in little-endian byte order, of the value. Use the exr::io::Data trait to extract binary values from this vector.

A custom attribute. Contains the type name of this value.

Implementations

impl AttributeValue

pub fn byte_size(&self) -> usize

Number of bytes this would consume in an exr file.

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

The exr name string of the type that an attribute can have.

pub fn write<W: Write>(&self, write: &mut W) -> UnitResult

Without validation, write this instance to the byte stream.

pub fn read( read: &mut PeekRead<impl Read>, kind: Text, byte_size: usize ) -> Result<Result<Self>>

Read the value without validating. Returns Ok(Ok(attribute)) for valid attributes. Returns Ok(Err(Error)) for invalid attributes from a valid byte source. Returns Err(Error) for invalid byte sources, for example for invalid files.

pub fn validate( &self, allow_sampling: bool, data_window: IntegerBounds, strict: bool ) -> UnitResult

Validate this instance.

pub fn to_i32(&self) -> Result<i32>

Return Ok(i32) if this attribute is an i32.

pub fn to_f32(&self) -> Result<f32>

Return Ok(f32) if this attribute is an f32.

pub fn into_text(self) -> Result<Text>

Return Ok(Text) if this attribute is a text.

pub fn to_text(&self) -> Result<&Text>

Return Ok(Text) if this attribute is a text.

pub fn to_chromaticities(&self) -> Result<Chromaticities>

Return Ok(Chromaticities) if this attribute is a chromaticities attribute.

pub fn to_time_code(&self) -> Result<TimeCode>

Return Ok(TimeCode) if this attribute is a time code.

Trait Implementations

impl Clone for AttributeValue

fn clone(&self) -> AttributeValue

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for AttributeValue

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

Formats the value using the given formatter.

impl PartialEq<AttributeValue> for AttributeValue

fn eq(&self, other: &AttributeValue) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for AttributeValue