Trait FitsHeaderValue 

pub trait FitsHeaderValue: Debug + RealAny {
    // Required methods
    fn from_bytes(raw: Vec<u8>) -> Result<Self, FitsHeaderError>
       where Self: Sized;
    fn to_bytes(&self) -> [u8; 70];
}

Available on crate feature fits only.

A trait that allows data to be serialized/deserialized as a FITS header value.

Required Methods

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

where Self: Sized,

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.

Implementations

impl dyn FitsHeaderValue

pub fn is<T: FitsHeaderValue + 'static>(&self) -> bool

Determines if the type of self is the same as T.

Implementations on Foreign Types

impl FitsHeaderValue for bool

use astro_rs::fits::FitsHeaderError;
use astro_rs::fits::FitsHeaderValue;

// successful deserialization
let true_value: bool = FitsHeaderValue::from_bytes(b"T".to_vec())?;
assert!(true_value);
let false_value: bool = FitsHeaderValue::from_bytes(b"F".to_vec())?;
assert!(!false_value);

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

// serialization
assert_eq!(true_value.to_bytes(), *b"                   T                                                  ");
assert_eq!(false_value.to_bytes(), *b"                   F                                                  ");

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

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

impl FitsHeaderValue for u8

use astro_rs::fits::FitsHeaderError;
use astro_rs::fits::FitsHeaderValue;

// successful deserialization
let max_value: u8 = FitsHeaderValue::from_bytes(b"255".to_vec())?;
assert_eq!(max_value, 255);
let min_value: u8 = FitsHeaderValue::from_bytes(b"0".to_vec())?;
assert_eq!(min_value, 0);

// failed deserialization
let result: Result<u8, FitsHeaderError> = FitsHeaderValue::from_bytes(b"300".to_vec());
assert!(result.is_err());
let result: Result<u8, FitsHeaderError> = FitsHeaderValue::from_bytes(b"Not a number".to_vec());
assert!(result.is_err());

// serialization
assert_eq!(max_value.to_bytes(), *b"                 255                                                  ");
assert_eq!(min_value.to_bytes(), *b"                   0                                                  ");

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

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

impl FitsHeaderValue for u16

use astro_rs::fits::FitsHeaderError;
use astro_rs::fits::FitsHeaderValue;

// successful deserialization
let max_value: u16 = FitsHeaderValue::from_bytes(b"65535".to_vec())?;
assert_eq!(max_value, 65535);
let min_value: u16 = FitsHeaderValue::from_bytes(b"0".to_vec())?;
assert_eq!(min_value, 0);

// failed deserialization
let result: Result<u16, FitsHeaderError> = FitsHeaderValue::from_bytes(b"66000".to_vec());
assert!(result.is_err());
let result: Result<u16, FitsHeaderError> = FitsHeaderValue::from_bytes(b"Not a number".to_vec());
assert!(result.is_err());

// serialization
assert_eq!(max_value.to_bytes(), *b"               65535                                                  ");
assert_eq!(min_value.to_bytes(), *b"                   0                                                  ");

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

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

impl FitsHeaderValue for u32

use astro_rs::fits::FitsHeaderError;
use astro_rs::fits::FitsHeaderValue;

// successful deserialization
let max_value: u32 = FitsHeaderValue::from_bytes(b"4294967295".to_vec())?;
assert_eq!(max_value, 4294967295);
let min_value: u32 = FitsHeaderValue::from_bytes(b"0".to_vec())?;
assert_eq!(min_value, 0);

// failed deserialization
let result: Result<u32, FitsHeaderError> = FitsHeaderValue::from_bytes(b"4300000000".to_vec());
assert!(result.is_err());
let result: Result<u32, FitsHeaderError> = FitsHeaderValue::from_bytes(b"Not a number".to_vec());
assert!(result.is_err());

// serialization
assert_eq!(max_value.to_bytes(), *b"          4294967295                                                  ");
assert_eq!(min_value.to_bytes(), *b"                   0                                                  ");

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

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

impl FitsHeaderValue for String

use astro_rs::fits::FitsHeaderError;
use astro_rs::fits::FitsHeaderValue;

// successful deserialization
let value: String = FitsHeaderValue::from_bytes(String::from("hello world").into_bytes())?;
assert_eq!(value, String::from("hello world"));
let quote_value: String = FitsHeaderValue::from_bytes(String::from("'this ''includes'' quotes'").into_bytes())?;
assert_eq!(quote_value, String::from("this 'includes' quotes"));

// failed deserialization
let result: Result<String, FitsHeaderError> = FitsHeaderValue::from_bytes(vec![0, 159, 146, 150]);
assert!(result.is_err());

// serialization
assert_eq!(value.to_bytes(), *b"'hello world'                                                         ");
assert_eq!(quote_value.to_bytes(), *b"'this ''includes'' quotes'                                            ");

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

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

Implementors

impl FitsHeaderValue for Bitpix

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      '                                                            ");