Struct HduList 

pub struct HduList<R> { /* private fields */ }

Available on crate feature fits only.

A representation of the entirety of a FITS file.

Implementations

impl<R: Read> HduList<R>

pub fn new(reader: BufReader<R>) -> Self

Constructs an empty HduList.

pub fn get_by_index(&mut self, index: usize) -> Option<&mut Hdu>

Retrieves the HDU at the given index, or None if an HDU doesn’t exist at the index.

Examples

use astro_rs::fits::*;

let mut hdu_list = HduList::default();
assert!(hdu_list.get_by_index(0).is_none());

hdu_list.push(primary_hdu::default());
assert!(hdu_list.get_by_index(0).is_some());

pub fn get_by_name(&mut self, name: &str) -> Option<&mut Hdu>

Retrieves the HDU with the given value for the EXTNAME keyword, or None if an HDU with the given name doesn’t exist.

Examples

use astro_rs::fits::*;

let mut hdu_list = HduList::default();
// empty list
assert!(hdu_list.get_by_name("hdu_name").is_none());

// name does not match
let mut img_hdu = image_hdu::default();
let name_card = FitsHeaderCard::from(*b"EXTNAME = 'name_of_hdu'                                                         ");
img_hdu.header.cards.insert(img_hdu.header.cards.len() - 1, name_card);
hdu_list.push(img_hdu);
assert!(hdu_list.get_by_name("hdu_name").is_none());

// name matches
let mut img_hdu = image_hdu::default();
let name_card = FitsHeaderCard::from(*b"EXTNAME = 'hdu_name'                                                            ");
img_hdu.header.cards.insert(img_hdu.header.cards.len() - 1, name_card);
hdu_list.push(img_hdu);
assert!(hdu_list.get_by_name("hdu_name").is_some());

pub fn first_mut(&mut self) -> Option<&mut Hdu>

Returns a mutable pointer to the first HDU, or None if the list is empty.

Examples

use astro_rs::fits::*;

let mut hdu_list = HduList::default();
assert!(hdu_list.first_mut().is_none());

hdu_list.push(primary_hdu::default());
assert!(hdu_list.first_mut().is_some());

pub fn iter_mut(&mut self) -> IterMut<'_, Hdu>

Deserializes all HDUs if necessary, then returns a mutable iterator over the HDUs.

Examples

use astro_rs::fits::*;

let mut hdu_list = HduList::default();
hdu_list.push(primary_hdu::default());

// find the primary HDU
assert!(hdu_list
    .iter_mut()
    .find_map(|hdu| if hdu.header.get_card(SIMPLE_KEYWORD).is_some() {
        Some(hdu)
    } else {
        None
    })
    .is_some())

pub fn insert(&mut self, index: usize, hdu: Hdu)

Deserializes all HDUs up to index if necessary, then inserts the given hdu.

Panics

Panics if index is out of bounds.

Examples

use astro_rs::fits::*;

let mut hdu_list = HduList::default();
// panics, index is out of bounds
hdu_list.insert(1, image_hdu::default());

use astro_rs::fits::*;

let mut hdu_list = HduList::default();
hdu_list.push(primary_hdu::default());
hdu_list.insert(1, image_hdu::default());
assert_eq!(hdu_list.iter_mut().count(), 2);

pub fn push(&mut self, hdu: Hdu)

Appends hdu to the end of the HDU list.

Examples

use astro_rs::fits::*;

let mut hdu_list = HduList::default();
hdu_list.push(primary_hdu::default());
assert_eq!(hdu_list.iter_mut().count(), 1);
hdu_list.push(image_hdu::default());
assert_eq!(hdu_list.iter_mut().count(), 2);

pub fn write<W: Write>( &mut self, writer: &mut BufWriter<W>, ) -> Result<(), Error>

Writes the HDU list via the given writer.

Examples

use astro_rs::fits::*;
use std::io::*;

let in_cursor = Cursor::new(SIMPLE_KEYWORD.to_vec());
let mut hdu_list = HduList::new(BufReader::new(in_cursor));
let out_cursor = Cursor::new(Vec::new());
let mut out_writer = BufWriter::new(out_cursor);
hdu_list.write(&mut out_writer)?;
assert_eq!(out_writer.get_ref().get_ref(), &SIMPLE_KEYWORD.to_vec());

pub fn is_header_valid(&mut self) -> Result<bool, FitsHeaderError>

Validates the existence and format of the SIMPLE header card.

Examples

use astro_rs::fits::*;

let mut hdu_list = HduList::default();
// empty header
assert!(!hdu_list.is_header_valid()?);

let mut hdu = Hdu::new();

// non-empty header missing simple card
let bitpix_card = FitsHeaderCard::from(*b"BITPIX  =                  -32 / FITS BITS/PIXEL                                ");
hdu.header.cards.insert(0, bitpix_card);
hdu_list.push(hdu);
assert!(!hdu_list.is_header_valid()?);

// valid header
let simple_card = FitsHeaderCard::from(*b"SIMPLE  =                    T / FITS STANDARD                                  ");
hdu_list.first_mut().unwrap().header.cards.insert(0, simple_card);
assert!(hdu_list.is_header_valid()?);

Trait Implementations

impl<R: Debug> Debug for HduList<R>

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

Formats the value using the given formatter.

impl Default for HduList<Cursor<Vec<u8>>>

fn default() -> Self

Returns the “default value” for a type.