Changeset 41269 for trunk/Ohana/src/opihi/lib.shell/VectorIO.c

Timestamp:

Feb 24, 2020, 3:19:09 PM (6 years ago)

Author:

eugene

Message:

adding string-type vectors to opihi

File:

• trunk/Ohana/src/opihi/lib.shell/VectorIO.c (modified) (6 diffs)

trunk/Ohana/src/opihi/lib.shell/VectorIO.c

@@ -2 +2 @@
 void gfits_compress_timing ();
   
+static int VectorGetMaxStringLength (Vector *vec) {
+
+  int MaxLength = 0;
+
+  if (vec[0].type != OPIHI_STR) return 0;
+
+  for (int i = 0; i < vec[0].Nelements; i++) {
+    MaxLength = MAX (MaxLength, strlen(vec[0].elements.Str[i]));
+  }
+  return MaxLength;
+}
+
 // write a set of vectors to a FITS FTable structure (vectors names become fits column names)
 static int WriteVectorTable (FTable *ftable, char *extname, Vector **vec, int Nvec, char *format, char nativeOrder) {
@@ -44 +56 @@
       }
       ptr = endptr; // this should now point at the letter that is the format type
-      if ((*ptr != 'B') && (*ptr != 'I') && (*ptr != 'J') && (*ptr != 'K') && (*ptr != 'D') && (*ptr != 'E')) {
+      if ((*ptr != 'B') && (*ptr != 'I') && (*ptr != 'J') && (*ptr != 'K') && (*ptr != 'D') && (*ptr != 'E') && (*ptr != 'A')) {
         gprint (GP_ERR, "error in binary table format %s: invalid character %c\n", format, *ptr);
         goto escape;
@@ -57 +69 @@
       // tformat[2*j + 1] = 0; // a bit sleazy : use a 2xN string to store N 1-byte strings
 
-      j += Nelement[Nfield]; // advance past 
+      // For numeric multi-valued fields, the number of elements from the format defines the number of
+      // vectors which go into that field.  For string-type vectors, the format specifies the maximum number of characters
+      // that go into the field.
+
+      // for example, a format code of 3E should match a list of three numeric-type vectors while a format code of 15A should
+      // match a single string-type vector which will supply up to 15 chars per row.
+
+      if (*ptr != 'A') {
+        j += Nelement[Nfield]; // advance past Nelement vectors
+      } else {
+        if (vec[j][0].type != OPIHI_STR) {
+          gprint (GP_ERR, "error in binary table format %s (mismatch between string format and numeric vector %s)\n", format, vec[j][0].name);
+          goto escape;
+        }
+        j ++; // advance past a single string-type vector (validate that?)
+      }
       if (j > Nvec) {
         gprint (GP_ERR, "error in binary table format %s (too few vectors for listed field)\n", format);
@@ -73 +100 @@
   } else {
     for (j = 0; j < Nvec; j++) {
-      // if the format is not defined, just use the native byte-widths
-      ALLOCATE (tformat[j], char, 2);
-      tformat[j][0] = (vec[j][0].type == OPIHI_FLT) ? 'D' : 'K'; // this depends on opihi_int == int64_t for Int
-      tformat[j][1] = 0;
-      Nelement[j] = 1;
+      switch (vec[j][0].type) {
+        case OPIHI_FLT:
+        case OPIHI_INT:
+          // if the format is not defined, just use the native byte-widths
+          ALLOCATE (tformat[j], char, 2);
+          tformat[j][0] = (vec[j][0].type == OPIHI_FLT) ? 'D' : 'K';
+          tformat[j][1] = 0;
+          Nelement[j] = 1;
+          break;
+        case OPIHI_STR:
+          // we need to examine the vector to determine the length
+          Nelement[j] = VectorGetMaxStringLength(vec[j]); 
+          int Nchar = snprintf (tformat[j], 0, "%d%c", Nelement[j], 'A');
+          ALLOCATE (tformat[j], char, Nchar + 1);
+          int Nout = snprintf (tformat[j], Nchar + 1, "%d%c", Nelement[j], 'A');
+          myAssert (Nout <= Nchar, "oops");
+          break;
+      }
     }
     Nfield = Nvec;
@@ -90 +130 @@
     // this call supported multiple columns per named field
     gfits_define_bintable_column (theader, tformat[j], vec[ivec][0].name, NULL, NULL, 1.0, 0.0);
-    ivec += Nelement[j];
+    if (vec[ivec][0].type == OPIHI_STR) {
+      ivec ++;
+    } else {
+      ivec += Nelement[j];
+    }
   }
 
@@ -109 +153 @@
     // the first vector provides the name for the field
     char *fieldname = vec[ivec][0].name;
-    for (int k = 0; k < Nelement[j]; k++, ivec++) {
+
+    if (vec[ivec][0].type == OPIHI_STR) {
+      // string-type vectors need to be copied into a contiguous buffer with the right dimensions:
       Vector *thisvec = vec[ivec];
-      if (thisvec->type == OPIHI_FLT) {
-        gfits_set_bintable_column_reformat (theader, ftable, fieldname, "double",  thisvec->elements.Flt, thisvec->Nelements, k, nativeOrder);
-      } else {
-        gfits_set_bintable_column_reformat (theader, ftable, fieldname, "int64_t", thisvec->elements.Int, thisvec->Nelements, k, nativeOrder);
+
+      ALLOCATE_PTR (strbuffer, char, Nelement[j]*thisvec->Nelements);
+      for (int i = 0; i < thisvec->Nelements; i++) {
+        int nChar = MIN (strlen (thisvec->elements.Str[i]), Nelement[j]);
+        // fprintf (stderr, "%d %d %d : %d : %d : %s\n", ivec, j, i, Nelement[j], nChar, thisvec->elements.Str[i]);
+        memcpy (&strbuffer[i*Nelement[j]], thisvec->elements.Str[i], nChar);
+      }
+      gfits_set_bintable_column (theader, ftable, fieldname, strbuffer, thisvec->Nelements);
+      free (strbuffer);
+      ivec ++;
+    } else {
+      for (int k = 0; k < Nelement[j]; k++, ivec++) {
+        Vector *thisvec = vec[ivec];
+        switch (thisvec->type) {
+          case OPIHI_FLT:
+            gfits_set_bintable_column_reformat (theader, ftable, fieldname, "double",  thisvec->elements.Flt, thisvec->Nelements, k, nativeOrder);
+            break;
+          case OPIHI_INT:
+            gfits_set_bintable_column_reformat (theader, ftable, fieldname, "int64_t", thisvec->elements.Int, thisvec->Nelements, k, nativeOrder);
+            break;
+        }
       }
     }