Enum noodles_bam::record::data::field::value::Value

pub enum Value {
    Char(char),
    Int8(i8),
    UInt8(u8),
    Int16(i16),
    UInt16(u16),
    Int32(i32),
    UInt32(u32),
    Float(f32),
    String(String),
    Hex(String),
    Int8Array(Vec<i8>),
    UInt8Array(Vec<u8>),
    Int16Array(Vec<i16>),
    UInt16Array(Vec<u16>),
    Int32Array(Vec<i32>),
    UInt32Array(Vec<u32>),
    FloatArray(Vec<f32>),
}

A BAM record data field value.

BAM record data field values support all the same types as a SAM record data field value:

• character (A),
• 32-bit integer (i),
• single-precision floating-point (f),
• string (Z),
• hex string (H),
• 8-bit integer array (Bc),
• 8-bit unsigned integer array (BC),
• 16-bit integer array (Bs),
• 16-bit unsigned integer array (BS),
• 32-bit integer array (Bi),
• 32-bit unsigned integer array (BI), and
• single-precision floating-point array (Bf),

Additionally, it is a superset of SAM record data field values, supporting additional single-value integer types:

• 8-bit integer (c),
• 8-bit unsigned integer (C),
• 16-bit integer (s),
• 16-bit unsigned integer (S), and
• 32-bit unsigned integer (I).

Variants

Char(char)

Tuple Fields

0: char

A character (A).

Int8(i8)

Tuple Fields

0: i8

An 8-bit integer (c).

UInt8(u8)

Tuple Fields

0: u8

An 8-bit unsigned integer (C).

Int16(i16)

Tuple Fields

0: i16

A 16-bit integer (s).

UInt16(u16)

Tuple Fields

0: u16

A 16-bit unsigned integer (S).

Int32(i32)

Tuple Fields

0: i32

A 32-bit integer (i).

UInt32(u32)

Tuple Fields

0: u32

A 32-bit unsigned integer (I).

Float(f32)

Tuple Fields

0: f32

A single-precision floating-point (f).

String(String)

Tuple Fields

0: String

A string (Z).

Hex(String)

Tuple Fields

0: String

A hex string (H).

Int8Array(Vec<i8>)

Tuple Fields

0: Vec<i8>

An 8-bit integer array (Bc).

UInt8Array(Vec<u8>)

Tuple Fields

0: Vec<u8>

An 8-bit unsigned integer array (BC).

Int16Array(Vec<i16>)

Tuple Fields

0: Vec<i16>

A 16-bit integer array (Bs).

UInt16Array(Vec<u16>)

Tuple Fields

0: Vec<u16>

A 16-bit unsigned integer array (BS).

Int32Array(Vec<i32>)

Tuple Fields

0: Vec<i32>

A 32-bit integer array (Bi).

UInt32Array(Vec<u32>)

Tuple Fields

0: Vec<u32>

A 32-bit unsigned integer array (BI).

FloatArray(Vec<f32>)

Tuple Fields

0: Vec<f32>

A single-precision floating-point array (Bf).

Implementations

impl Value

pub fn ty(&self) -> Type

Returns the type of the value.

Examples

use noodles_bam::record::data::field::{value::Type, Value};
assert_eq!(Value::Int32(0).ty(), Type::Int32);

pub fn subtype(&self) -> Option<Subtype>

Returns the subtype of the value.

Only arrays have subtypes.

Examples

use noodles_bam::record::data::field::{value::Subtype, Value};
assert_eq!(Value::UInt8Array(vec![0]).subtype(), Some(Subtype::UInt8));
assert_eq!(Value::Int32(0).subtype(), None);

pub fn as_char(&self) -> Option<char>

Returns the value as a character if it is a character.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Char('a').as_char(), Some('a'));
assert_eq!(Value::Int32(0).as_char(), None);

pub fn is_char(&self) -> bool

Returns whether the value is a character.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Char('a').is_char());
assert!(!Value::Int32(0).is_char());

pub fn as_int8(&self) -> Option<i8>

Returns the value as an 8-bit integer if it is an 8-bit integer.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Int8(0).as_int8(), Some(0));
assert_eq!(Value::Int32(0).as_int8(), None);

pub fn is_int8(&self) -> bool

Returns whether the value is an 8-bit integer.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Int8(0).is_int8());
assert!(!Value::Int32(0).is_int8());

pub fn as_uint8(&self) -> Option<u8>

Returns the value as an 8-bit unsigned integer if it is an 8-bit unsigned integer.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::UInt8(0).as_uint8(), Some(0));
assert_eq!(Value::Int32(0).as_uint8(), None);

pub fn is_uint8(&self) -> bool

Returns whether the value is an 8-bit unsigned integer.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::UInt8(0).is_uint8());
assert!(!Value::Int32(0).is_uint8());

pub fn as_int16(&self) -> Option<i16>

Returns the value as a 16-bit integer if it is a 16-bit integer.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Int16(0).as_int16(), Some(0));
assert_eq!(Value::Int32(0).as_int16(), None);

pub fn is_int16(&self) -> bool

Returns whether the value is a 16-bit integer.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Int16(0).is_int16());
assert!(!Value::Int32(0).is_int16());

pub fn as_uint16(&self) -> Option<u16>

Returns the value as a 16-bit unsigned integer if it is a 16-bit unsigned integer.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::UInt16(0).as_uint16(), Some(0));
assert_eq!(Value::Int32(0).as_uint16(), None);

pub fn is_uint16(&self) -> bool

Returns whether the value is an 16-bit unsigned integer.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::UInt16(0).is_uint16());
assert!(!Value::Int32(0).is_uint16());

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

Returns the value as a 32-bit integer if it is a 32-bit integer.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Int32(0).as_int32(), Some(0));
assert_eq!(Value::Char('a').as_int32(), None);

pub fn is_int32(&self) -> bool

Returns whether the value is a 32-bit integer.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Int32(0).is_int32());
assert!(!Value::Char('a').is_int32());

pub fn as_uint32(&self) -> Option<u32>

Returns the value as a 32-bit unsigned integer if it is a 32-bit unsigned integer.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::UInt32(0).as_uint32(), Some(0));
assert_eq!(Value::Int32(0).as_uint32(), None);

pub fn is_uint32(&self) -> bool

Returns whether the value is an 32-bit unsigned integer.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::UInt32(0).is_uint32());
assert!(!Value::Int32(0).is_uint32());

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

Returns the value as a 64-bit integer, if it is an integer.

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

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Int32(0).as_int(), Some(0));
assert_eq!(Value::Char('a').as_int(), None);

pub fn is_int(&self) -> bool

Returns whether the value is an integer.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Int32(0).is_int());
assert!(!Value::Char('a').is_int());

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

Returns the value as a single-precision floating-point if it is a single-precision float-point.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Float(0.0).as_float(), Some(0.0));
assert_eq!(Value::Int32(0).as_float(), None);

pub fn is_float(&self) -> bool

Returns whether the value is a single-precision floating-point.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Float(0.0).is_float());
assert!(!Value::Int32(0).is_float());

pub fn as_str(&self) -> Option<&str>

Returns the value as a string slice if it is a string slice.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::String(String::from("noodles")).as_str(), Some("noodles"));
assert_eq!(Value::Int32(0).as_str(), None);

pub fn is_str(&self) -> bool

Returns whether the value is a string.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::String(String::from("noodles")).is_str());
assert!(!Value::Int32(0).is_str());

pub fn as_hex(&self) -> Option<&str>

Returns the value as a string slice of hex if it is a string slice of hex.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Hex(String::from("cafe")).as_hex(), Some("cafe"));
assert_eq!(Value::Int32(0).as_hex(), None);

pub fn is_hex(&self) -> bool

Returns whether the value is a hex string.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Hex(String::from("cafe")).is_hex());
assert!(!Value::Int32(0).is_hex());

pub fn as_int8_array(&self) -> Option<&[i8]>

Returns the value as an array of 8-bit integers if it is an array of 8-bit integers.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Int8Array(vec![0]).as_int8_array(), Some(&[0][..]));
assert_eq!(Value::Int32(0).as_int8_array(), None);

pub fn is_int8_array(&self) -> bool

Returns whether the value is an 8-bit integer array.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Int8Array(vec![0]).is_int8_array());
assert!(!Value::Int32(0).is_int8_array());

pub fn as_uint8_array(&self) -> Option<&[u8]>

Returns the value as an array of 8-bit unsigned integers if it is an array of 8-bit unsigned integers.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::UInt8Array(vec![0]).as_uint8_array(), Some(&[0][..]));
assert_eq!(Value::Int32(0).as_uint8_array(), None);

pub fn is_uint8_array(&self) -> bool

Returns whether the value is an 8-bit unsigned integer array.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::UInt8Array(vec![0]).is_uint8_array());
assert!(!Value::Int32(0).is_uint8_array());

pub fn as_int16_array(&self) -> Option<&[i16]>

Returns the value as an array of 16-bit integers if it is an array of 16-bit integers.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Int16Array(vec![0]).as_int16_array(), Some(&[0][..]));
assert_eq!(Value::Int32(0).as_int16_array(), None);

pub fn is_int16_array(&self) -> bool

Returns whether the value is a 16-bit integer array.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Int16Array(vec![0]).is_int16_array());
assert!(!Value::Int32(0).is_int16_array());

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

Returns the value as an array of 16-bit unsigned integers if it is an array of 16-bit unsigned integers.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::UInt16Array(vec![0]).as_uint16_array(), Some(&[0][..]));
assert_eq!(Value::Int32(0).as_uint16_array(), None);

pub fn is_uint16_array(&self) -> bool

Returns whether the value is a 16-bit unsigned integer array.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::UInt16Array(vec![0]).is_uint16_array());
assert!(!Value::Int32(0).is_int16_array());

pub fn as_int32_array(&self) -> Option<&[i32]>

Returns the value as an array of 32-bit integers if it is an array of 32-bit integers.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::Int32Array(vec![0]).as_int32_array(), Some(&[0][..]));
assert_eq!(Value::Int32(0).as_int32_array(), None);

pub fn is_int32_array(&self) -> bool

Returns whether the value is a 32-bit integer array.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Int32Array(vec![0]).is_int32_array());
assert!(!Value::Int32(0).is_int16_array());

pub fn as_uint32_array(&self) -> Option<&[u32]>

Returns the value as an array of 32-bit unsigned integers if it is an array of 32-bit unsigned integers.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::UInt32Array(vec![0]).as_uint32_array(), Some(&[0][..]));
assert_eq!(Value::Int32(0).as_uint32_array(), None);

pub fn is_uint32_array(&self) -> bool

Returns whether the value is a 32-bit unsigned integer array.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::UInt32Array(vec![0]).is_uint32_array());
assert!(!Value::Int32(0).is_int32_array());

pub fn as_float_array(&self) -> Option<&[f32]>

Returns the value as an array of single-precision floating-points if it is an array of single-precision floating-points.

Examples

use noodles_bam::record::data::field::Value;
assert_eq!(Value::FloatArray(vec![0.0]).as_float_array(), Some(&[0.0][..]));
assert_eq!(Value::Int32(0).as_float_array(), None);

pub fn is_float_array(&self) -> bool

Returns whether the value is a 32-bit integer array.

Examples

use noodles_bam::record::data::field::Value;
assert!(Value::Int32Array(vec![0]).is_int32_array());
assert!(!Value::Int32(0).is_int16_array());

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl From<Value> for Value

fn from(value: Value) -> Self

Performs the conversion.

impl PartialEq<Value> for Value

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

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

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

This method tests for !=.

impl StructuralPartialEq for Value