use std::io::{Read, Write};
use std::path::{Path, PathBuf};
use crate::error::{FitsError, Result};
use crate::hdu::Hdu;
use crate::header::Header;
use crate::io::{self, DiskDriver, Driver, MemoryDriver};
use crate::status::{
BAD_FILEPTR, BAD_HDU_NUM, END_OF_FILE, FILE_NOT_CREATED, FILE_NOT_OPENED, NO_END, READONLY_FILE,
};
use crate::types::{HduType, READONLY, READWRITE, RECORD_LEN};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AccessMode {
ReadOnly,
ReadWrite,
}
impl AccessMode {
#[must_use]
pub const fn code(self) -> i32 {
match self {
Self::ReadOnly => READONLY,
Self::ReadWrite => READWRITE,
}
}
}
pub(crate) enum Backend {
Disk(DiskDriver),
Memory(MemoryDriver),
}
impl Driver for Backend {
fn read_at(&mut self, pos: u64, buf: &mut [u8]) -> Result<usize> {
match self {
Self::Disk(d) => d.read_at(pos, buf),
Self::Memory(d) => d.read_at(pos, buf),
}
}
fn write_at(&mut self, pos: u64, buf: &[u8]) -> Result<()> {
match self {
Self::Disk(d) => d.write_at(pos, buf),
Self::Memory(d) => d.write_at(pos, buf),
}
}
fn len(&self) -> Result<u64> {
match self {
Self::Disk(d) => d.len(),
Self::Memory(d) => d.len(),
}
}
fn truncate(&mut self, len: u64) -> Result<()> {
match self {
Self::Disk(d) => d.truncate(len),
Self::Memory(d) => d.truncate(len),
}
}
fn flush(&mut self) -> Result<()> {
match self {
Self::Disk(d) => d.flush(),
Self::Memory(d) => d.flush(),
}
}
}
pub(crate) struct Inner {
pub(crate) io: Backend,
pub(crate) writable: bool,
path: Option<PathBuf>,
pub(crate) hdus: Vec<Hdu>,
pub(crate) current: usize,
pub(crate) dirty: bool,
gzip_out: Option<PathBuf>,
scratch: Option<PathBuf>,
emit_stdout: bool,
pub(crate) nextkey: usize,
pub(crate) compression: crate::compress::CompressionRequest,
}
impl Inner {
fn new(
io: Backend,
writable: bool,
path: Option<PathBuf>,
hdus: Vec<Hdu>,
gzip_out: Option<PathBuf>,
scratch: Option<PathBuf>,
emit_stdout: bool,
) -> Self {
Self {
io,
writable,
path,
hdus,
current: 0,
dirty: false,
gzip_out,
scratch,
emit_stdout,
nextkey: 1,
compression: crate::compress::CompressionRequest::default(),
}
}
pub(crate) fn last_end(&self) -> Result<u64> {
let last = self
.hdus
.last()
.ok_or_else(|| FitsError::new(BAD_HDU_NUM))?;
last.end()
}
pub(crate) fn bump_offsets_from(&mut self, from_idx: usize, delta: i64) {
for hdu in self.hdus.iter_mut().skip(from_idx) {
if delta >= 0 {
hdu.header_start = hdu.header_start.saturating_add(delta as u64);
hdu.data_start = hdu.data_start.saturating_add(delta as u64);
} else {
let d = (-delta) as u64;
hdu.header_start = hdu.header_start.saturating_sub(d);
hdu.data_start = hdu.data_start.saturating_sub(d);
}
}
}
}
pub struct FitsFile {
inner: Option<Inner>,
}
impl std::fmt::Debug for FitsFile {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match &self.inner {
None => f.debug_struct("FitsFile").field("closed", &true).finish(),
Some(inner) => f
.debug_struct("FitsFile")
.field("path", &inner.path)
.field("writable", &inner.writable)
.field("hdu_count", &inner.hdus.len())
.finish(),
}
}
}
impl FitsFile {
pub fn create(path: impl AsRef<Path>) -> Result<Self> {
let path = path.as_ref();
let (path, clobber) = split_clobber(path);
if is_stdout_name(&path) {
let mut f = Self::create_memory()?;
if let Some(inner) = f.inner.as_mut() {
inner.emit_stdout = true;
}
return Ok(f);
}
if clobber && path.exists() {
std::fs::remove_file(&path)
.map_err(|e| FitsError::with_message(FILE_NOT_CREATED, e.to_string()))?;
}
if ends_with_gz(&path) {
if path.exists() {
return Err(FitsError::new(FILE_NOT_CREATED));
}
return create_gzip_dest(path);
}
let mut io = Backend::Disk(DiskDriver::create(&path)?);
let hdu = Hdu::empty_primary()?;
let bytes = hdu.header.to_record_bytes();
io::write_all(&mut io, &bytes)?;
Ok(Self {
inner: Some(Inner::new(
io,
true,
Some(path),
vec![hdu],
None,
None,
false,
)),
})
}
pub fn create_memory() -> Result<Self> {
let mut io = Backend::Memory(MemoryDriver::new());
let hdu = Hdu::empty_primary()?;
let bytes = hdu.header.to_record_bytes();
io::write_all(&mut io, &bytes)?;
Ok(Self {
inner: Some(Inner::new(io, true, None, vec![hdu], None, None, false)),
})
}
pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
let data = maybe_gunzip(bytes)?;
if data.is_empty() {
return Err(FitsError::with_message(FILE_NOT_OPENED, "file is empty"));
}
let mut mem = MemoryDriver::from_vec(data);
let hdus = parse_hdus_io(&mut mem)?;
Ok(Self {
inner: Some(Inner::new(
Backend::Memory(mem),
true,
None,
hdus,
None,
None,
false,
)),
})
}
pub fn open_reader<R: Read>(mut reader: R) -> Result<Self> {
let mut bytes = Vec::new();
reader.read_to_end(&mut bytes).map_err(io::map_read_err)?;
Self::from_bytes(&bytes)
}
pub fn open(path: impl AsRef<Path>, mode: AccessMode) -> Result<Self> {
let path = path.as_ref();
if is_stdin_name(path) {
return Self::open_reader(std::io::stdin());
}
let writable = mode == AccessMode::ReadWrite;
let actual = resolve_open_path(path)?;
if path_is_gzip(&actual)? {
return open_gzip(&actual, writable);
}
let mut disk = DiskDriver::open(&actual, writable)?;
if disk.len()? == 0 {
return Err(FitsError::with_message(FILE_NOT_OPENED, "file is empty"));
}
let hdus = parse_hdus_io(&mut disk)?;
Ok(Self {
inner: Some(Inner::new(
Backend::Disk(disk),
writable,
Some(actual),
hdus,
None,
None,
false,
)),
})
}
pub fn close(mut self) -> Result<()> {
self.flush_inner()?;
self.persist_special(true)?;
self.take_and_cleanup_scratch();
Ok(())
}
pub fn flush(&mut self) -> Result<()> {
self.flush_inner()
}
pub fn hdu_count(&self) -> Result<usize> {
Ok(self.inner()?.hdus.len())
}
pub fn hdu_type(&self) -> Result<HduType> {
let inner = self.inner()?;
Ok(logical_hdu_type(&inner.hdus[inner.current]))
}
pub fn hdunum(&self) -> Result<usize> {
Ok(self.inner()?.current + 1)
}
pub fn movabs_hdu(&mut self, hdunum: usize) -> Result<HduType> {
self.flush_inner()?;
let inner = self.inner_mut()?;
if hdunum < 1 {
return Err(FitsError::new(BAD_HDU_NUM));
}
if hdunum > inner.hdus.len() {
return Err(FitsError::new(END_OF_FILE));
}
inner.current = hdunum - 1;
inner.nextkey = 1;
Ok(logical_hdu_type(&inner.hdus[inner.current]))
}
pub fn movrel_hdu(&mut self, nmove: i32) -> Result<HduType> {
let here = self.hdunum()? as i32;
let dest = here + nmove;
if dest < 1 {
return Err(FitsError::new(BAD_HDU_NUM));
}
self.movabs_hdu(dest as usize)
}
pub fn movnam_hdu(&mut self, hdutype: i32, extname: &str, extver: i32) -> Result<HduType> {
self.flush_inner()?;
let inner = self.inner()?;
let mut found = None;
for (i, hdu) in inner.hdus.iter().enumerate() {
if hdutype >= 0 && logical_hdu_type(hdu).code() != hdutype {
continue;
}
let name = hdu
.header
.get_string("EXTNAME")
.map(|(v, _)| v)
.unwrap_or_default();
if !name.eq_ignore_ascii_case(extname) {
continue;
}
let ver = hdu.header.get_i64("EXTVER").unwrap_or(1) as i32;
if extver != 0 && ver != extver {
continue;
}
found = Some(i);
break;
}
let idx = found.ok_or_else(|| FitsError::new(BAD_HDU_NUM))?;
let inner = self.inner_mut()?;
inner.current = idx;
inner.nextkey = 1;
Ok(logical_hdu_type(&inner.hdus[idx]))
}
pub fn filename(&self) -> Result<String> {
Ok(self
.inner()?
.path
.as_ref()
.and_then(|p| p.file_name())
.and_then(|s| s.to_str())
.unwrap_or("")
.to_string())
}
pub fn filemode(&self) -> Result<i32> {
Ok(if self.inner()?.writable {
READWRITE
} else {
READONLY
})
}
pub fn delete_file(mut self) -> Result<()> {
let path = self.inner()?.path.clone();
let gzip = self.inner()?.gzip_out.clone();
self.take_and_cleanup_scratch();
if let Some(p) = gzip.or(path) {
let _ = std::fs::remove_file(p);
}
Ok(())
}
pub fn hdrpos(&self) -> Result<(usize, usize)> {
let inner = self.inner()?;
Ok((inner.hdus[inner.current].header.len(), inner.nextkey.max(1)))
}
pub fn write_record(&mut self, card: &str) -> Result<()> {
self.header_mut()?.write_record(card);
Ok(())
}
pub fn get_num_hdus(&self) -> Result<i32> {
Ok(self.hdu_count()? as i32)
}
pub fn header(&self) -> Result<&Header> {
let inner = self.inner()?;
Ok(&inner.hdus[inner.current].header)
}
pub fn header_mut(&mut self) -> Result<&mut Header> {
self.require_write()?;
let inner = self.inner_mut()?;
inner.dirty = true;
let idx = inner.current;
Ok(&mut inner.hdus[idx].header)
}
pub(crate) fn require_write(&self) -> Result<()> {
if self.inner()?.writable {
Ok(())
} else {
Err(FitsError::new(READONLY_FILE))
}
}
pub fn to_bytes(&mut self) -> Result<Vec<u8>> {
self.flush_inner()?;
io::read_all(&mut self.inner_mut()?.io)
}
pub(crate) fn inner(&self) -> Result<&Inner> {
self.inner
.as_ref()
.ok_or_else(|| FitsError::new(BAD_FILEPTR))
}
pub(crate) fn inner_mut(&mut self) -> Result<&mut Inner> {
self.inner
.as_mut()
.ok_or_else(|| FitsError::new(BAD_FILEPTR))
}
fn flush_inner(&mut self) -> Result<()> {
let writable = self.inner()?.writable;
let dirty = self.inner()?.dirty;
let is_bin = self.inner()?.hdus[self.inner()?.current].hdu_type == HduType::BinaryTable;
if !writable {
return if dirty {
Err(FitsError::new(READONLY_FILE))
} else {
self.inner_mut()?.io.flush()
};
}
if is_bin {
self.sync_binary_heap_keywords()?;
}
let inner = self.inner_mut()?;
if inner.dirty {
flush_header_and_maybe_shift(inner)?;
inner.dirty = false;
}
inner.io.flush()?;
Ok(())
}
fn persist_special(&mut self, emit_stdout: bool) -> Result<()> {
let gzip_out = self.inner.as_ref().and_then(|i| i.gzip_out.clone());
let do_stdout = emit_stdout && self.inner.as_ref().is_some_and(|i| i.emit_stdout);
if gzip_out.is_none() && !do_stdout {
return Ok(());
}
if let Some(path) = gzip_out {
write_gzip_from_driver(&mut self.inner_mut()?.io, &path)?;
}
if do_stdout {
let bytes = io::read_all(&mut self.inner_mut()?.io)?;
std::io::stdout()
.write_all(&bytes)
.map_err(io::map_write_err)?;
std::io::stdout().flush().map_err(io::map_write_err)?;
}
Ok(())
}
fn take_and_cleanup_scratch(&mut self) {
let scratch = self.inner.as_ref().and_then(|i| i.scratch.clone());
self.inner.take();
if let Some(p) = scratch {
let _ = std::fs::remove_file(p);
}
}
}
impl Drop for FitsFile {
fn drop(&mut self) {
let _ = self.flush_inner();
let _ = self.persist_special(false);
self.take_and_cleanup_scratch();
}
}
fn flush_header_and_maybe_shift(inner: &mut Inner) -> Result<()> {
let idx = inner.current;
let header_start = inner.hdus[idx].header_start;
let old_data_start = inner.hdus[idx].data_start;
let mut hb = inner.hdus[idx].header.to_record_bytes();
let data_bytes = inner.hdus[idx].data_bytes().unwrap_or(0);
let old_header_len = old_data_start.saturating_sub(header_start);
if data_bytes > 0 && (hb.len() as u64) < old_header_len {
hb.resize(old_header_len as usize, b' ');
}
let new_data_start = header_start + hb.len() as u64;
let delta = new_data_start as i64 - old_data_start as i64;
if delta > 0 {
io::insert_bytes(&mut inner.io, old_data_start, delta as u64, b' ')?;
inner.bump_offsets_from(idx + 1, delta);
} else if delta < 0 {
io::delete_bytes(&mut inner.io, new_data_start, (-delta) as u64)?;
inner.bump_offsets_from(idx + 1, delta);
}
inner.io.write_at(header_start, &hb)?;
inner.hdus[idx].hdu_type = hdu_type_from_header(&inner.hdus[idx].header);
inner.hdus[idx].data_start = new_data_start;
let tail = if data_bytes > 0 {
crate::convert::pad_data_len(data_bytes)
} else {
0
};
if inner.hdus[idx].hdu_type == HduType::AsciiTable && tail > data_bytes {
io::write_fill(
&mut inner.io,
new_data_start + data_bytes,
tail - data_bytes,
b' ',
)?;
}
let file_end = inner.last_end()?;
if inner.io.len()? > file_end {
inner.io.truncate(file_end)?;
}
Ok(())
}
fn parse_hdus_io(io: &mut dyn Driver) -> Result<Vec<Hdu>> {
let file_len = io.len()?;
let mut hdus = Vec::new();
let mut offset = 0u64;
while offset < file_len {
let Some((header, header_len)) = read_header_at(io, offset, file_len)? else {
break;
};
let hdu_type = hdu_type_from_header(&header);
let mut hdu = Hdu {
hdu_type,
header,
header_start: offset,
data_start: offset + header_len,
};
let data_unit = hdu.data_unit_len()?;
hdu.data_start = offset + header_len;
hdus.push(hdu);
offset += header_len + data_unit;
if header_len == 0 {
break;
}
}
if hdus.is_empty() {
return Err(FitsError::with_message(FILE_NOT_OPENED, "no HDUs found"));
}
Ok(hdus)
}
fn read_header_at(
io: &mut dyn Driver,
offset: u64,
file_len: u64,
) -> Result<Option<(Header, u64)>> {
if offset >= file_len {
return Ok(None);
}
let mut buf = Vec::new();
loop {
let pos = offset + buf.len() as u64;
if pos >= file_len {
if buf.is_empty() {
return Ok(None);
}
return Err(FitsError::new(NO_END));
}
let mut rec = [0u8; RECORD_LEN];
let want = RECORD_LEN.min((file_len - pos) as usize);
let n = io.read_at(pos, &mut rec[..want])?;
if n == 0 {
if buf.is_empty() {
return Ok(None);
}
return Err(FitsError::new(NO_END));
}
if buf.is_empty() && rec[..n].iter().all(|&b| b == 0) {
return Ok(None);
}
buf.extend_from_slice(&rec[..n]);
if n < RECORD_LEN {
return Err(FitsError::new(NO_END));
}
match Header::parse(&buf) {
Ok((header, header_len)) => return Ok(Some((header, header_len))),
Err(e) if e.status == NO_END => {
if buf.len() > RECORD_LEN * 1024 {
return Err(e);
}
}
Err(e) => return Err(e),
}
}
}
fn create_gzip_dest(path: PathBuf) -> Result<FitsFile> {
#[cfg(feature = "gzip")]
{
let (disk, scratch) = DiskDriver::create_temp()?;
let mut io = Backend::Disk(disk);
let hdu = Hdu::empty_primary()?;
let bytes = hdu.header.to_record_bytes();
io::write_all(&mut io, &bytes)?;
Ok(FitsFile {
inner: Some(Inner::new(
io,
true,
Some(path.clone()),
vec![hdu],
Some(path),
Some(scratch),
false,
)),
})
}
#[cfg(not(feature = "gzip"))]
{
let mut io = Backend::Memory(MemoryDriver::new());
let hdu = Hdu::empty_primary()?;
let bytes = hdu.header.to_record_bytes();
io::write_all(&mut io, &bytes)?;
Ok(FitsFile {
inner: Some(Inner::new(
io,
true,
Some(path.clone()),
vec![hdu],
Some(path),
None,
false,
)),
})
}
}
fn open_gzip(actual: &Path, writable: bool) -> Result<FitsFile> {
#[cfg(feature = "gzip")]
{
let (mut disk, scratch) = DiskDriver::create_temp()?;
crate::io::gzip::decompress_file_to_driver(actual, &mut disk)?;
if disk.len()? == 0 {
let _ = std::fs::remove_file(&scratch);
return Err(FitsError::with_message(FILE_NOT_OPENED, "file is empty"));
}
let hdus = match parse_hdus_io(&mut disk) {
Ok(h) => h,
Err(e) => {
let _ = std::fs::remove_file(&scratch);
return Err(e);
}
};
let gzip_out = if writable {
Some(actual.to_path_buf())
} else {
None
};
Ok(FitsFile {
inner: Some(Inner::new(
Backend::Disk(disk),
writable,
Some(actual.to_path_buf()),
hdus,
gzip_out,
Some(scratch),
false,
)),
})
}
#[cfg(not(feature = "gzip"))]
{
let _ = writable;
Err(FitsError::with_message(
FILE_NOT_OPENED,
"gzip support is disabled (rebuild with the gzip feature)",
))
}
}
pub(crate) fn logical_hdu_type(hdu: &Hdu) -> HduType {
if hdu.header.is_compressed_image() {
HduType::Image
} else {
hdu.hdu_type
}
}
fn hdu_type_from_header(header: &Header) -> HduType {
if header.card_by_name("SIMPLE").is_some() {
return HduType::Image;
}
if let Ok(card) = header.get_i64("BITPIX") {
let _ = card;
}
if let Some(c) = header.card_by_name("XTENSION") {
let text = c.as_str().unwrap_or("");
if text.contains("BINTABLE") {
return HduType::BinaryTable;
}
if text.contains("TABLE") {
return HduType::AsciiTable;
}
}
HduType::Image
}
fn is_stdout_name(path: &Path) -> bool {
path == Path::new("-") || path == Path::new("stdout") || path == Path::new("STDOUT")
}
fn is_stdin_name(path: &Path) -> bool {
path == Path::new("-") || path == Path::new("stdin") || path == Path::new("STDIN")
}
fn ends_with_gz(path: &Path) -> bool {
path.as_os_str()
.to_str()
.is_some_and(|s| s.ends_with(".gz"))
}
fn is_gzip_magic(bytes: &[u8]) -> bool {
bytes.len() >= 2 && bytes[0] == 0x1f && bytes[1] == 0x8b
}
fn resolve_open_path(path: &Path) -> Result<PathBuf> {
if path.exists() {
return Ok(path.to_path_buf());
}
let mut gz = path.as_os_str().to_os_string();
gz.push(".gz");
let gz_path = PathBuf::from(gz);
if gz_path.exists() {
return Ok(gz_path);
}
Err(FitsError::with_message(
FILE_NOT_OPENED,
format!("could not open {}", path.display()),
))
}
fn path_is_gzip(path: &Path) -> Result<bool> {
let mut f = std::fs::File::open(path).map_err(io::map_open_err)?;
let mut mag = [0u8; 2];
let n = f.read(&mut mag).map_err(io::map_read_err)?;
Ok(is_gzip_magic(&mag[..n]))
}
fn maybe_gunzip(bytes: &[u8]) -> Result<Vec<u8>> {
if !is_gzip_magic(bytes) {
return Ok(bytes.to_vec());
}
#[cfg(feature = "gzip")]
{
crate::io::gzip::decompress(bytes)
}
#[cfg(not(feature = "gzip"))]
{
Err(FitsError::with_message(
FILE_NOT_OPENED,
"gzip support is disabled (rebuild with the gzip feature)",
))
}
}
fn write_gzip_from_driver(io: &mut dyn Driver, path: &Path) -> Result<()> {
#[cfg(feature = "gzip")]
{
crate::io::gzip::compress_driver_to_file(io, path)
}
#[cfg(not(feature = "gzip"))]
{
let _ = (io, path);
Err(FitsError::with_message(
FILE_NOT_CREATED,
"gzip support is disabled (rebuild with the gzip feature)",
))
}
}
fn split_clobber(path: &Path) -> (PathBuf, bool) {
if let Some(s) = path.to_str() {
let trimmed = s.trim_start();
if let Some(rest) = trimmed.strip_prefix('!') {
return (PathBuf::from(rest), true);
}
}
(path.to_path_buf(), false)
}
pub fn fits_create_file(name: &str) -> Result<FitsFile> {
FitsFile::create(name)
}
pub fn fits_open_file(name: &str, mode: AccessMode) -> Result<FitsFile> {
FitsFile::open(name, mode)
}
pub fn fits_close_file(f: FitsFile) -> Result<()> {
f.close()
}
pub fn fits_create_memfile() -> Result<FitsFile> {
FitsFile::create_memory()
}