Add vector type support (ex: '100E')

Author: fotonick

CHANGELOG.md

@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 ### Added
+* Support for vector data-types in reading and writing tables.
 ### Changed
 ### Removed
 

fitsio/src/fitsfile.rs

@@ -368,27 +368,29 @@ impl FitsFile {
                 for i in 0..num_cols {
                     let mut name_buffer: Vec<libc::c_char> = vec![0; 71];
                     let mut type_buffer: Vec<libc::c_char> = vec![0; 71];
+                    let mut repeats: libc::c_long = 0;
                     unsafe {
                         fits_get_bcolparms(
                             self.fptr.as_mut() as *mut _,
                             i + 1,
                             name_buffer.as_mut_ptr(),
                             ptr::null_mut(),
                             type_buffer.as_mut_ptr(),
-                            ptr::null_mut(),
+                            &mut repeats as *mut libc::c_long,
                             ptr::null_mut(),
                             ptr::null_mut(),
                             ptr::null_mut(),
                             ptr::null_mut(),
                             &mut status,
                         );
                     }
-
-                    column_descriptions.push(ConcreteColumnDescription {
+                    let mut col = ConcreteColumnDescription {
                         name: stringutils::buf_to_string(&name_buffer)?,
                         data_type: stringutils::buf_to_string(&type_buffer)?
                             .parse::<ColumnDataDescription>()?,
-                    });
+                    };
+                    col.data_type.repeat = repeats as usize;
+                    column_descriptions.push(col);
                 }
 
                 HduInfo::TableInfo {

fitsio/src/longnam.rs

@@ -5,15 +5,16 @@
 #![allow(unused_imports, dead_code)]
 
 pub(crate) use crate::sys::{
-    ffclos, ffcopy, ffcrim, ffcrtb, ffdcol, ffdhdu, ffflmd, ffgbcl, ffgcdw, ffgcno, ffgcvd, ffgcve,
-    ffgcvi, ffgcvj, ffgcvjj, ffgcvk, ffgcvl, ffgcvs, ffgcvui, ffgcvuj, ffgcvujj, ffgcvuk, ffghdn,
-    ffghdt, ffgidm, ffgiet, ffgisz, ffgkyd, ffgkye, ffgkyj, ffgkyjj, ffgkyl, ffgkys, ffgncl,
-    ffgnrw, ffgpv, ffgsv, fficol, ffinit, ffmahd, ffmnhd, ffopen, ffpcl, ffpcls, ffphps, ffpky,
-    ffpkyd, ffpkye, ffpkys, ffppr, ffpss, ffrsim, ffthdu, fitsfile, LONGLONG,
+    ffclos, ffcopy, ffcrim, ffcrtb, ffdcol, ffdhdu, ffflmd, ffgbcl, ffgcdw, ffgcno, ffgcvb, ffgcvd,
+    ffgcve, ffgcvi, ffgcvj, ffgcvjj, ffgcvk, ffgcvl, ffgcvs, ffgcvsb, ffgcvui, ffgcvuj, ffgcvujj,
+    ffgcvuk, ffgcx, ffghdn, ffghdt, ffgidm, ffgiet, ffgisz, ffgkyd, ffgkye, ffgkyj, ffgkyjj,
+    ffgkyl, ffgkys, ffgncl, ffgnrw, ffgpv, ffgsv, fficol, ffinit, ffmahd, ffmnhd, ffopen, ffpcl,
+    ffpcls, ffpclx, ffphps, ffpky, ffpkyd, ffpkye, ffpkys, ffppr, ffpss, ffrsim, ffthdu, fitsfile,
+    LONGLONG,
 };
 pub use libc::{
-    c_char, c_double, c_float, c_int, c_long, c_short, c_uint, c_ulong, c_ulonglong, c_ushort,
-    c_void,
+    c_char, c_double, c_float, c_int, c_long, c_schar, c_short, c_uchar, c_uint, c_ulong,
+    c_ulonglong, c_ushort, c_void,
 };
 
 pub(crate) unsafe fn fits_close_file(fptr: *mut fitsfile, status: *mut libc::c_int) -> c_int {
@@ -148,6 +149,38 @@ pub(crate) unsafe fn fits_read_col_log(
     )
 }
 
+pub(crate) unsafe fn fits_read_col_byt(
+    fptr: *mut fitsfile,
+    colnum: c_int,
+    firstrow: LONGLONG,
+    firstelem: LONGLONG,
+    nelem: LONGLONG,
+    nulval: c_uchar,
+    array: *mut c_uchar,
+    anynul: *mut c_int,
+    status: *mut c_int,
+) -> c_int {
+    ffgcvb(
+        fptr, colnum, firstrow, firstelem, nelem, nulval, array, anynul, status,
+    )
+}
+
+pub(crate) unsafe fn fits_read_col_sbyt(
+    fptr: *mut fitsfile,
+    colnum: c_int,
+    firstrow: LONGLONG,
+    firstelem: LONGLONG,
+    nelem: LONGLONG,
+    nulval: c_schar,
+    array: *mut c_schar,
+    anynul: *mut c_int,
+    status: *mut c_int,
+) -> c_int {
+    ffgcvsb(
+        fptr, colnum, firstrow, firstelem, nelem, nulval, array, anynul, status,
+    )
+}
+
 pub(crate) unsafe fn fits_read_col_sht(
     fptr: *mut fitsfile,
     colnum: c_int,

fitsio/src/tables.rs

@@ -6,6 +6,7 @@ use crate::longnam::*;
 use crate::stringutils::status_to_string;
 use crate::types::DataType;
 use std::ffi;
+use std::mem::size_of;
 use std::ops::Range;
 use std::ptr;
 use std::str::FromStr;
@@ -59,7 +60,6 @@ macro_rules! reads_col_impl {
                         ..
                     }) => {
                         let num_output_rows = range.end - range.start;
-                        let mut out = vec![$nullval; num_output_rows];
                         let test_name = name.into();
                         let column_number = column_descriptions
                             .iter()
@@ -68,14 +68,22 @@ macro_rules! reads_col_impl {
                                 "Cannot find column {:?}",
                                 test_name
                             )))?;
+                        let col_desc = &column_descriptions[column_number];
+                        #[allow(clippy::manual_bits)]
+                        let repeat = if col_desc.data_type.typ == ColumnDataType::Bit {
+                            col_desc.data_type.repeat / (size_of::<$t>() * 8)
+                        } else {
+                            col_desc.data_type.repeat
+                        };
+                        let mut out = vec![$nullval; num_output_rows * repeat];
                         let mut status = 0;
                         unsafe {
                             $func(
                                 fits_file.fptr.as_mut() as *mut _,
                                 (column_number + 1) as i32,
                                 (range.start + 1) as i64,
                                 1,
-                                num_output_rows as _,
+                                (num_output_rows * repeat) as _,
                                 $nullval,
                                 out.as_mut_ptr(),
                                 ptr::null_mut(),
@@ -121,6 +129,12 @@ macro_rules! reads_col_impl {
                                 "Cannot find column {:?}",
                                 test_name
                             )))?;
+                        let repeat = column_descriptions[column_number].data_type.repeat;
+                        if repeat > 1 {
+                            unimplemented!(
+                                "reading a single cell of a vector value (e.g., TFORM1 = 100E) is unimplemented. Call read_col() or read_col_range()."
+                            )
+                        }
                         let mut status = 0;
 
                         unsafe {
@@ -248,6 +262,8 @@ impl ReadsCol for bool {
     }
 }
 
+reads_col_impl!(u8, fits_read_col_byt, 0);
+reads_col_impl!(i8, fits_read_col_sbyt, 0);
 reads_col_impl!(i16, fits_read_col_sht, 0);
 reads_col_impl!(u16, fits_read_col_usht, 0);
 reads_col_impl!(i32, fits_read_col_int, 0);
@@ -387,15 +403,15 @@ macro_rules! writes_col_impl {
                         let colno = hdu.get_column_no(fits_file, col_name.into())?;
                         // TODO: check that the column exists in the file
                         let mut status = 0;
-                        let n_elements = rows.end - rows.start;
+                        let n_rows = rows.end - rows.start;
                         unsafe {
                             fits_write_col(
                                 fits_file.fptr.as_mut() as *mut _,
                                 $data_type.into(),
                                 (colno + 1) as _,
                                 (rows.start + 1) as _,
                                 1,
-                                n_elements as _,
+                                n_rows as _,
                                 col_data.as_ptr() as *mut _,
                                 &mut status,
                             );
@@ -415,6 +431,8 @@ macro_rules! writes_col_impl {
     };
 }
 
+writes_col_impl!(u8, DataType::TBYTE);
+writes_col_impl!(i8, DataType::TSBYTE);
 writes_col_impl!(u32, DataType::TUINT);
 #[cfg(all(target_pointer_width = "64", not(target_os = "windows")))]
 writes_col_impl!(u64, DataType::TULONG);
@@ -639,14 +657,20 @@ impl From<ColumnDataDescription> for String {
 #[allow(missing_docs)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ColumnDataType {
+    Logical,
     Bit,
-    Bool,
+    Byte,
+    SignedByte,
+    Short,
+    UnsignedShort,
     Int,
+    Long,
+    UnsignedLong,
     Float,
     Text,
     Double,
-    Short,
-    Long,
+    LongLong,
+    UnsignedLongLong,
     String,
 }
 
@@ -655,14 +679,19 @@ impl From<ColumnDataType> for String {
         use self::ColumnDataType::*;
 
         match orig {
+            Logical => "L",
             Bit => "X",
-            Bool => "B",
-            Int => "J",
+            Byte => "B",
+            SignedByte => "S",
+            Short => "I",
+            UnsignedShort => "U",
+            Int | Long => "J",
+            UnsignedLong => "U",
             Float => "E",
             Text | String => "A",
             Double => "D",
-            Short => "I",
-            Long => "K",
+            LongLong => "K",
+            UnsignedLongLong => "W",
         }
         .to_string()
     }
@@ -712,15 +741,19 @@ impl FromStr for ColumnDataDescription {
         };
 
         let data_type = match data_type_char {
+            'L' => ColumnDataType::Logical,
             'X' => ColumnDataType::Bit,
-            'B' => ColumnDataType::Bool,
+            'B' => ColumnDataType::Byte,
+            'S' => ColumnDataType::SignedByte,
             'E' => ColumnDataType::Float,
             'J' => ColumnDataType::Int,
             'D' => ColumnDataType::Double,
             'I' => ColumnDataType::Short,
-            'K' => ColumnDataType::Long,
+            'K' => ColumnDataType::LongLong,
             'A' => ColumnDataType::String,
-            'L' => ColumnDataType::Bool,
+            'U' => ColumnDataType::UnsignedShort,
+            'V' => ColumnDataType::UnsignedLong,
+            'W' => ColumnDataType::UnsignedLongLong,
             _ => panic!(
                 "Have not implemented str -> ColumnDataType for {}",
                 data_type_char
@@ -772,8 +805,9 @@ macro_rules! datatype_into_impl {
                     DataType::TINT => 31,
                     DataType::TULONG => 40,
                     DataType::TLONG => 41,
-                    DataType::TLONGLONG => 81,
                     DataType::TFLOAT => 42,
+                    DataType::TULONGLONG => 80,
+                    DataType::TLONGLONG => 81,
                     DataType::TDOUBLE => 82,
                     DataType::TCOMPLEX => 83,
                     DataType::TDBLCOMPLEX => 163,

fitsio/src/types.rs

@@ -16,8 +16,9 @@ pub enum DataType {
     TINT,
     TULONG,
     TLONG,
-    TLONGLONG,
     TFLOAT,
+    TULONGLONG,
+    TLONGLONG,
     TDOUBLE,
     TCOMPLEX,
     TDBLCOMPLEX,

fitsio/tests/test_bit_datatype.rs

@@ -19,10 +19,10 @@ fn test_writing_bit_data_type() {
     let tmp_dir = Builder::new().prefix("fitsio-").tempdir().unwrap();
     let file_path = tmp_dir.path().join("example.fits");
 
+    let data: Vec<u32> = (0..64).collect();
     {
         let mut fitsfile = FitsFile::create(&file_path).open().unwrap();
 
-        let data: Vec<u32> = (0..64).collect();
         let col = ColumnDescription::new("BITMASK")
             .with_type(ColumnDataType::Bit)
             .create()
@@ -38,5 +38,5 @@ fn test_writing_bit_data_type() {
 
     let table_hdu = f.hdu("DATA").unwrap();
     let flags: Vec<u32> = dbg!(table_hdu.read_col(&mut f, "BITMASK").unwrap());
-    assert_eq!(flags.len(), 64);
+    assert!(data.iter().zip(&flags).all(|(a, b)| a == b));
 }