Enum noodles::sam::record::data::field::Value

pub enum Value {
    Char(char),
    Int(i64),
    Float(f32),
    String(String),
    Hex(String),
    Int8Array(Vec<i8, Global>),
    UInt8Array(Vec<u8, Global>),
    Int16Array(Vec<i16, Global>),
    UInt16Array(Vec<u16, Global>),
    Int32Array(Vec<i32, Global>),
    UInt32Array(Vec<u32, Global>),
    FloatArray(Vec<f32, Global>),
}

A SAM record data field value.

Variants

Char(char)

A character (A).

Tuple Fields of Char

0: char

Int(i64)

An integer (i).

Tuple Fields of Int

0: i64

Float(f32)

A single-precision floating-point (f).

Tuple Fields of Float

0: f32

String(String)

A string (Z).

Tuple Fields of String

0: String

Hex(String)

A hex string (H).

Tuple Fields of Hex

0: String

Int8Array(Vec<i8, Global>)

An 8-bit integer array (Bc).

Tuple Fields of Int8Array

0: Vec<i8, Global>

UInt8Array(Vec<u8, Global>)

An 8-bit unsigned integer array (BC).

Tuple Fields of UInt8Array

0: Vec<u8, Global>

Int16Array(Vec<i16, Global>)

A 16-bit integer array (Bs).

Tuple Fields of Int16Array

0: Vec<i16, Global>

UInt16Array(Vec<u16, Global>)

A 16-bit unsigned integer array (BS).

Tuple Fields of UInt16Array

0: Vec<u16, Global>

Int32Array(Vec<i32, Global>)

A 32-bit integer array (Bi).

Tuple Fields of Int32Array

0: Vec<i32, Global>

UInt32Array(Vec<u32, Global>)

A 32-bit unsigned integer array (BI).

Tuple Fields of UInt32Array

0: Vec<u32, Global>

FloatArray(Vec<f32, Global>)

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

Tuple Fields of FloatArray

0: Vec<f32, Global>

Implementations

impl Value

pub fn ty(&self) -> Type

Returns the type of the value.

Examples

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

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

Returns the subtype of the value.

Only arrays have subtypes.

Examples

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

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

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

Examples

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

pub fn is_char(&self) -> bool

Returns whether the value is a character.

Examples

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

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

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

Examples

use noodles_sam::record::data::field::Value;
assert_eq!(Value::Int(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_sam::record::data::field::Value;
assert!(Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::Float(0.0).as_float(), Some(0.0));
assert_eq!(Value::Int(0).as_float(), None);

pub fn is_float(&self) -> bool

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

Examples

use noodles_sam::record::data::field::Value;
assert!(Value::Float(0.0).is_float());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::String(String::from("noodles")).as_str(), Some("noodles"));
assert_eq!(Value::Int(0).as_str(), None);

pub fn is_str(&self) -> bool

Returns whether the value is a string.

Examples

use noodles_sam::record::data::field::Value;
assert!(Value::String(String::from("noodles")).is_str());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::Hex(String::from("cafe")).as_hex(), Some("cafe"));
assert_eq!(Value::Int(0).as_hex(), None);

pub fn is_hex(&self) -> bool

Returns whether the value is a hex string.

Examples

use noodles_sam::record::data::field::Value;
assert!(Value::Hex(String::from("cafe")).is_hex());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::Int8Array(vec![0]).as_int8_array(), Some(&[0][..]));
assert_eq!(Value::Int(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_sam::record::data::field::Value;
assert!(Value::Int8Array(vec![0]).is_int8_array());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::UInt8Array(vec![0]).as_uint8_array(), Some(&[0][..]));
assert_eq!(Value::Int(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_sam::record::data::field::Value;
assert!(Value::UInt8Array(vec![0]).is_uint8_array());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::Int16Array(vec![0]).as_int16_array(), Some(&[0][..]));
assert_eq!(Value::Int(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_sam::record::data::field::Value;
assert!(Value::Int16Array(vec![0]).is_int16_array());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::UInt16Array(vec![0]).as_uint16_array(), Some(&[0][..]));
assert_eq!(Value::Int(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_sam::record::data::field::Value;
assert!(Value::UInt16Array(vec![0]).is_uint16_array());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::Int32Array(vec![0]).as_int32_array(), Some(&[0][..]));
assert_eq!(Value::Int(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_sam::record::data::field::Value;
assert!(Value::Int32Array(vec![0]).is_int32_array());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::UInt32Array(vec![0]).as_uint32_array(), Some(&[0][..]));
assert_eq!(Value::Int(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_sam::record::data::field::Value;
assert!(Value::UInt32Array(vec![0]).is_uint32_array());
assert!(!Value::Int(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_sam::record::data::field::Value;
assert_eq!(Value::FloatArray(vec![0.0]).as_float_array(), Some(&[0.0][..]));
assert_eq!(Value::Int(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_sam::record::data::field::Value;
assert!(Value::Int32Array(vec![0]).is_int32_array());
assert!(!Value::Int(0).is_int16_array());

Trait Implementations

impl Clone for Value

pub 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

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

Formats the value using the given formatter.

impl Display for Value

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

Formats the value using the given formatter.

impl From<Value> for Value

pub fn from(value: Value) -> Value

Performs the conversion.

impl FromStr for Value

type Err = ParseError

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<Value, <Value as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq<Value> for Value

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

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

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

This method tests for !=.

impl StructuralPartialEq for Value