use crate::card::{
Card, format_exp_double, format_fixed_double, format_string_value, make_card_string,
};
use crate::datetime::{is_fits_date, now_fits_datetime};
use crate::error::Result;
use crate::file::FitsFile;
use crate::header::PrimaryInfo;
impl FitsFile {
pub fn write_key_str(&mut self, name: &str, value: &str, comm: Option<&str>) -> Result<()> {
self.header_mut()?.write_string(name, value, comm)
}
pub fn write_key_log(&mut self, name: &str, value: bool, comm: Option<&str>) -> Result<()> {
self.header_mut()?.write_logical(name, value, comm)
}
pub fn write_key_lng(&mut self, name: &str, value: i64, comm: Option<&str>) -> Result<()> {
self.header_mut()?.write_long(name, value, comm)
}
pub fn write_key_ulng(&mut self, name: &str, value: u64, comm: Option<&str>) -> Result<()> {
self.header_mut()?.write_ulong(name, value, comm)
}
pub fn write_key_flt(
&mut self,
name: &str,
value: f64,
decim: usize,
comm: Option<&str>,
) -> Result<()> {
self.header_mut()?.write_float_exp(name, value, decim, comm)
}
pub fn write_key_fixflt(
&mut self,
name: &str,
value: f64,
decim: usize,
comm: Option<&str>,
) -> Result<()> {
self.header_mut()?
.write_fixed_double(name, value, decim, comm)
}
pub fn write_key_dbl(
&mut self,
name: &str,
value: f64,
decim: usize,
comm: Option<&str>,
) -> Result<()> {
self.write_key_flt(name, value, decim, comm)
}
pub fn write_key_fixdbl(
&mut self,
name: &str,
value: f64,
decim: usize,
comm: Option<&str>,
) -> Result<()> {
self.write_key_fixflt(name, value, decim, comm)
}
pub fn write_key_null(&mut self, name: &str, comm: Option<&str>) -> Result<()> {
self.header_mut()?.write_null(name, comm)
}
pub fn write_comment(&mut self, comm: &str) -> Result<()> {
self.header_mut()?.write_comment(comm);
Ok(())
}
pub fn write_history(&mut self, hist: &str) -> Result<()> {
self.header_mut()?.write_history(hist);
Ok(())
}
pub fn write_date(&mut self) -> Result<()> {
let dt = now_fits_datetime();
self.header_mut()?.write_date_value(&dt)
}
pub fn write_date_value(&mut self, datetime: &str) -> Result<()> {
self.header_mut()?.write_date_value(datetime)
}
pub fn write_key_unit(&mut self, name: &str, unit: &str) -> Result<()> {
self.header_mut()?.set_unit(name, unit)
}
pub fn write_key_cmp(
&mut self,
name: &str,
real: f64,
imag: f64,
decim: usize,
comm: Option<&str>,
) -> Result<()> {
self.header_mut()?
.write_complex_exp(name, real, imag, decim, comm)
}
pub fn write_key_fixcmp(
&mut self,
name: &str,
real: f64,
imag: f64,
decim: usize,
comm: Option<&str>,
) -> Result<()> {
self.header_mut()?
.write_complex_fixed(name, real, imag, decim, comm)
}
pub fn read_key_str(&self, name: &str) -> Result<(String, String)> {
self.header()?.get_string(name)
}
pub fn read_key_log(&self, name: &str) -> Result<(bool, String)> {
self.header()?.get_logical(name)
}
pub fn read_key_lng(&self, name: &str) -> Result<i64> {
self.header()?.get_i64(name)
}
pub fn read_key_dbl(&self, name: &str) -> Result<f64> {
self.header()?.get_f64(name)
}
pub fn read_card(&self, name: &str) -> Result<Card> {
self.header()?
.card_by_name(name)
.copied()
.ok_or_else(|| crate::FitsError::new(crate::status::KEY_NO_EXIST))
}
pub fn read_record(&mut self, n: usize) -> Result<Card> {
let idx = if n == 0 { self.inner()?.nextkey } else { n };
let card = self.header()?.record(idx)?;
if let Ok(inner) = self.inner_mut() {
inner.nextkey = idx + 1;
}
Ok(card)
}
pub fn read_key_unit(&self, name: &str) -> Result<String> {
self.header()?.get_unit(name)
}
pub fn hdrspace(&self) -> Result<(usize, usize)> {
let n = self.header()?.len();
let used_in_rec = (n + 1) % 36; let more = if used_in_rec == 0 {
0
} else {
36 - used_in_rec
};
Ok((n, more))
}
pub fn update_key_str(&mut self, name: &str, value: &str, comm: Option<&str>) -> Result<()> {
let v = format_string_value(value);
self.header_mut()?.update_with(name, &v, comm)
}
pub fn update_key_log(&mut self, name: &str, value: bool, comm: Option<&str>) -> Result<()> {
let v = if value { "T" } else { "F" };
self.header_mut()?.update_with(name, v, comm)
}
pub fn update_key_lng(&mut self, name: &str, value: i64, comm: Option<&str>) -> Result<()> {
self.header_mut()?
.update_with(name, &value.to_string(), comm)
}
pub fn update_key_dbl(
&mut self,
name: &str,
value: f64,
decim: usize,
comm: Option<&str>,
) -> Result<()> {
let v = format_exp_double(value, decim);
self.header_mut()?.update_with(name, &v, comm)
}
pub fn update_key_fixdbl(
&mut self,
name: &str,
value: f64,
decim: usize,
comm: Option<&str>,
) -> Result<()> {
let v = format_fixed_double(value, decim);
self.header_mut()?.update_with(name, &v, comm)
}
pub fn update_key_null(&mut self, name: &str, comm: Option<&str>) -> Result<()> {
self.header_mut()?.update_with(name, " ", comm)
}
pub fn modify_key_str(&mut self, name: &str, value: &str, comm: Option<&str>) -> Result<()> {
let v = format_string_value(value);
self.header_mut()?.modify_with(name, &v, comm)
}
pub fn modify_key_lng(&mut self, name: &str, value: i64, comm: Option<&str>) -> Result<()> {
self.header_mut()?
.modify_with(name, &value.to_string(), comm)
}
pub fn insert_key_str(
&mut self,
pos: usize,
name: &str,
value: &str,
comm: Option<&str>,
) -> Result<()> {
let v = format_string_value(value);
let s = make_card_string(name, &v, comm)?;
self.header_mut()?
.insert_record_at(pos, Card::from_text(&s))
}
pub fn insert_record(&mut self, pos: usize, card: &str) -> Result<()> {
self.header_mut()?
.insert_record_at(pos, Card::from_text(card))
}
pub fn delete_key(&mut self, name: &str) -> Result<()> {
self.header_mut()?.delete_key(name)
}
pub fn delete_record(&mut self, n: usize) -> Result<()> {
self.header_mut()?.delete_record(n)
}
pub fn read_imghdr(&self) -> Result<PrimaryInfo> {
self.header()?.primary_info()
}
pub fn is_date_keyword(&self, name: &str) -> bool {
self.read_key_str(name)
.map(|(v, _)| is_fits_date(&v))
.unwrap_or(false)
}
pub fn read_keyword(&mut self, name: &str) -> Result<(String, String)> {
let (val, comm) = self.header()?.raw_value_comment(name)?;
if let Some(n) = self.header()?.cards().iter().position(|c| {
c.keyword_name()
.map(|(nm, _)| nm.eq_ignore_ascii_case(name))
.unwrap_or(false)
}) {
if let Ok(inner) = self.inner_mut() {
inner.nextkey = n + 2;
}
}
Ok((val, comm))
}
pub fn read_keyn(&mut self, n: usize) -> Result<(String, String, String)> {
let card = self.header()?.record(n)?;
let (name, _) = card.keyword_name()?;
let (val, comm) = card.parse_value_comment()?;
if let Ok(inner) = self.inner_mut() {
inner.nextkey = n + 1;
}
Ok((name, val, comm))
}
pub fn modify_name(&mut self, old: &str, new: &str) -> Result<()> {
let card = self.read_card(old)?;
let mut c = card;
c.set_keyword_name(new);
self.header_mut()?.replace_name(old, c)
}
pub fn modify_comment(&mut self, name: &str, comm: &str) -> Result<()> {
let (val, _) = self.header()?.raw_value_comment(name)?;
self.header_mut()?.modify_with(name, &val, Some(comm))
}
pub fn modify_record(&mut self, n: usize, card: &str) -> Result<()> {
let idx = n.wrapping_sub(1);
self.header_mut()?
.replace_record_idx(idx, crate::card::Card::from_text(card))
}
pub fn update_card(&mut self, name: &str, card: &str) -> Result<()> {
if self.header()?.card_by_name(name).is_some() {
let c = crate::card::Card::from_text(card);
self.header_mut()?.replace_name(name, c)
} else {
self.write_record(card)
}
}
pub fn read_keys_lng(&self, root: &str, start: i32, nmax: usize) -> Result<(Vec<i64>, usize)> {
Ok(self.header()?.get_keys_long(root, start, nmax))
}
pub fn read_keys_str(
&self,
root: &str,
start: i32,
nmax: usize,
) -> Result<(Vec<String>, usize)> {
let mut out = Vec::new();
for i in 0..nmax {
let name = format!("{root}{}", start as usize + i);
match self.header()?.get_string(&name) {
Ok((v, _)) => out.push(v),
Err(_) => break,
}
}
let n = out.len();
Ok((out, n))
}
pub fn write_keys_str(
&mut self,
root: &str,
start: i32,
values: &[&str],
comm: Option<&str>,
) -> Result<()> {
for (i, val) in values.iter().enumerate() {
let name = format!("{root}{}", start as usize + i);
self.write_key_str(&name, val, comm)?;
}
Ok(())
}
pub fn write_keys_lng(
&mut self,
root: &str,
start: i32,
values: &[i64],
comm: Option<&str>,
) -> Result<()> {
for (i, val) in values.iter().enumerate() {
let name = format!("{root}{}", start as usize + i);
self.write_key_lng(&name, *val, comm)?;
}
Ok(())
}
pub fn write_key_time(
&mut self,
name: &str,
intg: i64,
frac: f64,
comm: Option<&str>,
) -> Result<()> {
let v = format!("{}.{}", intg, format_frac(frac));
self.header_mut()?.update_with(name, &v, comm)
}
pub fn find_next_key(
&mut self,
inclist: &[&str],
exclist: &[&str],
) -> Result<crate::card::Card> {
let start = self.inner()?.nextkey.max(1);
let cards = self.inner()?.hdus[self.inner()?.current]
.header
.cards()
.to_vec();
for (i, card) in cards.iter().enumerate().skip(start.saturating_sub(1)) {
let Ok((name, _)) = card.keyword_name() else {
continue;
};
if matches_any(&name, inclist) && !matches_any(&name, exclist) {
self.inner_mut()?.nextkey = i + 2;
return Ok(*card);
}
}
Err(crate::FitsError::new(crate::status::KEY_NO_EXIST))
}
pub fn write_keys_template(&mut self, path: impl AsRef<std::path::Path>) -> Result<()> {
let text = std::fs::read_to_string(path.as_ref()).map_err(|e| {
crate::FitsError::with_message(crate::status::FILE_NOT_OPENED, e.to_string())
})?;
for raw in text.lines() {
let line = raw.trim();
if line.is_empty() {
continue;
}
let lower = line.to_ascii_lowercase();
if lower == "end" {
break;
}
if let Some(rest) = line.strip_prefix('-') {
let mut parts = rest.split_whitespace();
let old = parts.next().unwrap_or("");
if let Some(new) = parts.next() {
let _ = self.modify_name(old, new);
} else {
let _ = self.delete_key(old.trim());
}
continue;
}
if lower.starts_with("comment") {
let comm = line[7..].trim_start();
self.write_comment(comm)?;
continue;
}
if lower.starts_with("history") {
let hist = line[7..].trim_start();
self.write_history(hist)?;
continue;
}
self.write_record(line)?;
}
Ok(())
}
pub fn write_key_longstr(&mut self, name: &str, value: &str, comm: Option<&str>) -> Result<()> {
if value.len() <= 68 {
return self.write_key_str(name, value, comm);
}
let mut rest = value;
let first_n = 67usize.min(rest.len());
let mut first = rest[..first_n].to_string();
first.push('&');
self.write_key_str(name, &first, comm)?;
rest = &rest[first_n..];
while !rest.is_empty() {
let n = 67usize.min(rest.len());
let mut chunk = rest[..n].to_string();
rest = &rest[n..];
if !rest.is_empty() {
chunk.push('&');
}
let card = format!("CONTINUE '{}'", chunk.replace('\'', "''"));
self.write_record(&card)?;
}
Ok(())
}
pub fn write_key_longwarn(&mut self) -> Result<()> {
self.write_key_str(
"LONGSTRN",
"OGIP 1.0",
Some("The OGIP long string convention may be used."),
)
}
pub fn read_key_longstr(&mut self, name: &str) -> Result<(String, String)> {
let (val, comm) = self.read_key_str(name)?;
let mut out = val;
if out.ends_with('&') {
out.pop();
let cards = self.header()?.cards().to_vec();
let start = cards.iter().position(|c| {
c.keyword_name()
.map(|(n, _)| n.eq_ignore_ascii_case(name))
.unwrap_or(false)
});
if let Some(i) = start {
for c in cards.iter().skip(i + 1) {
let text = c.as_str().unwrap_or("");
if !text.starts_with("CONTINUE") {
break;
}
if let Ok((v, _)) = c.parse_value_comment() {
let s = crate::card::unquote_fits_string(&v);
let amp = s.ends_with('&');
out.push_str(s.trim_end_matches('&'));
if !amp {
break;
}
}
}
}
}
Ok((out, comm))
}
}
fn matches_any(name: &str, pats: &[&str]) -> bool {
if pats.is_empty() {
return false;
}
pats.iter().any(|p| glob_match(p, name))
}
fn glob_match(pat: &str, name: &str) -> bool {
let p = pat.to_ascii_uppercase();
let n = name.to_ascii_uppercase();
let mut pi = 0;
let pb = p.as_bytes();
let nb = n.as_bytes();
let mut ni = 0;
let mut star = None;
while ni < nb.len() {
if pi < pb.len() && (pb[pi] == b'?' || pb[pi] == nb[ni]) {
pi += 1;
ni += 1;
} else if pi < pb.len() && pb[pi] == b'*' {
star = Some((pi, ni));
pi += 1;
} else if let Some((sp, sn)) = star {
pi = sp + 1;
ni = sn + 1;
star = Some((sp, ni));
} else {
return false;
}
}
while pi < pb.len() && pb[pi] == b'*' {
pi += 1;
}
pi == pb.len()
}
fn format_frac(frac: f64) -> String {
let s = format!("{frac:.16}");
s.trim_start_matches("0.").trim_end_matches('0').to_string()
}
pub fn fits_write_key_str(
f: &mut FitsFile,
name: &str,
value: &str,
comm: Option<&str>,
) -> Result<()> {
f.write_key_str(name, value, comm)
}
pub fn fits_read_key_str(f: &FitsFile, name: &str) -> Result<(String, String)> {
f.read_key_str(name)
}
pub fn fits_write_date(f: &mut FitsFile) -> Result<()> {
f.write_date()
}