Enum noodles_sam::alignment::record::data::field::value::Value

pub enum Value<'a> {
    Character(u8),
    Int8(i8),
    UInt8(u8),
    Int16(i16),
    UInt16(u16),
    Int32(i32),
    UInt32(u32),
    Float(f32),
    String(&'a BStr),
    Hex(&'a BStr),
    Array(Array<'a>),
}

An alignment record data field value.

Variants

Character(u8)

A character (A).

Int8(i8)

An 8-bit integer (c).

UInt8(u8)

An 8-bit unsigned integer (C).

Int16(i16)

A 16-bit integer (s).

UInt16(u16)

A 16-bit unsigned integer (S).

Int32(i32)

A 32-bit integer (i).

UInt32(u32)

A 32-bit unsigned integer (I).

Float(f32)

A single-precision floating-point (f).

String(&'a BStr)

A string (Z).

Hex(&'a BStr)

A hex string (H).

Array(Array<'a>)

An array (B).

Implementations

impl<'a> Value<'a>

pub fn ty(&self) -> Type

Return the type of the value.

Examples

use noodles_sam::alignment::record::data::field::{Type, Value};
assert_eq!(Value::UInt8(0).ty(), Type::UInt8);

pub fn as_int(&self) -> Option<i64>

Returns the value as a 64-bit integer.

This is a convenience method that converts any integer to an i64, which captures the entire range of all record data field integer values.

Examples

use noodles_sam::alignment::record::data::field::Value;
assert_eq!(Value::Int8(8).as_int(), Some(8));
assert_eq!(Value::UInt32(13).as_int(), Some(13));
assert!(Value::Float(0.0).as_int().is_none());

Trait Implementations

impl<'a> Debug for Value<'a>

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

Formats the value using the given formatter.

impl<'a> From<&'a Value> for Value<'a>

fn from(value_buf: &'a Value) -> Self

Converts to this type from the input type.

impl<'a> TryFrom<Value<'a>> for Value

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Value<'a>) -> Result<Self, Self::Error>

Performs the conversion.