Struct TForm

pub struct TForm {
    pub r: usize,
    pub t: TFormType,
    pub a: String,
}

Available on crate feature fits only.

A value corresponding to the TFORM keyword.

Fields

r: usize

The repeat count

t: TFormType

The field type

a: String

Undefined additional characters

Implementations

impl TForm

pub fn value(&self) -> usize

Gets the number of bytes required by the column.

pub fn create_column<T>( &self, data: &[u8], column_start: usize, row_len: usize, num_rows: usize, ) -> Box<Vec<T>>

Creates a column of values from the given data.

Trait Implementations

impl Clone for TForm

fn clone(&self) -> TForm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TForm

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

Formats the value using the given formatter.

impl FitsHeaderValue for TForm

use astro_rs::fits::*;

// successful deserialization
let double_value: TForm = FitsHeaderValue::from_bytes(b"'1D      '".to_vec())?;
assert_eq!(double_value.value(), 8);
let repeat_int_value: TForm = FitsHeaderValue::from_bytes(b"'2I      '".to_vec())?;
assert_eq!(repeat_int_value.value(), 4);
let comment_char_value: TForm = FitsHeaderValue::from_bytes(b"'1A comment'".to_vec())?;
assert_eq!(comment_char_value.value(), 1);
let short_complex_value: TForm = FitsHeaderValue::from_bytes(b"'M       '".to_vec())?;
assert_eq!(short_complex_value.value(), 16);

// failed deserialization
let result: Result<TForm, FitsHeaderError> = FitsHeaderValue::from_bytes(b"U".to_vec());
assert!(result.is_err());
let result: Result<TForm, FitsHeaderError> = FitsHeaderValue::from_bytes(b"nonsense".to_vec());
assert!(result.is_err());

// serialization
assert_eq!(double_value.to_bytes(), *b"'1D      '                                                            ");
assert_eq!(repeat_int_value.to_bytes(), *b"'2I      '                                                            ");
assert_eq!(comment_char_value.to_bytes(), *b"'1A comment'                                                          ");
assert_eq!(short_complex_value.to_bytes(), *b"'1M      '                                                            ");

fn from_bytes(raw: Vec<u8>) -> Result<Self, FitsHeaderError>

Attempts to deserialize a value from the given bytes. The given bytes shall not be padded by spaces.

fn to_bytes(&self) -> [u8; 70]

Serializes the value to bytes. The bytes shall include padding spaces.