Merge pull request #9 from jeromekelleher/handle-full-missing-fields

Handle full missing fields

Author: jeromekelleher

lib/tests.c

@@ -121,16 +121,16 @@ test_variant_encoder_minimal(void)
     const char alt_data[] = "TC";
     const int32_t qual_data[] = { 1000, 12 };
     const char filter_data[] = "PASSPASS";
-    const int32_t an_data[] = { 8, 9 };
-    const char* aa_data = "GT";
+    const int32_t an_data[] = { -1, 9 };
+    const char* aa_data = "G.";
     const int32_t gt_data[] = { 0, 0, 0, 1, 1, 1, 1, 0 };
     const int8_t gt_phased_data[] = { 0, 1, 1, 0 };
-    const int32_t hq_data[] = { 10, 15, 7, 12, 8, 9, 10, 11 };
+    const int32_t hq_data[] = { 10, 15, 7, 12, -1, -1, -1, -1};
     int ret, j;
     vcz_variant_encoder_t writer;
     const char *expected[] = {
-        "X\t123\tRS1\tA\tT\t1000\tPASS\tAN=8;AA=G\tFORMAT=GT:HQ\t0/0:10,15\t0|1:7,12",
-        "YY\t45678\tRS2\tG\tC\t12\tPASS\tAN=9;AA=T\tFORMAT=GT:HQ\t1|1:8,9\t1/0:10,11",
+        "X\t123\tRS1\tA\tT\t1000\tPASS\tAA=G\tGT:HQ\t0/0:10,15\t0|1:7,12",
+        "YY\t45678\tRS2\tG\tC\t12\tPASS\tAN=9\tGT\t1|1\t1/0",
     };
     char buf[1000];
 
@@ -149,7 +149,7 @@ test_variant_encoder_minimal(void)
 
     printf("\n");
     vcz_variant_encoder_print_state(&writer, _devnull);
-    vcz_variant_encoder_print_state(&writer, stdout);
+    /* vcz_variant_encoder_print_state(&writer, stdout); */
 
     for (j = 0; j < num_rows; j++) {
         ret = vcz_variant_encoder_write_row(&writer, j, buf, 1000);

lib/vcf_encoder.c

@@ -55,6 +55,32 @@ vcz_itoa(int32_t value, char *buf)
     return p;
 }
 
+static bool
+int32_all_missing(const int32_t *restrict data, size_t n)
+{
+    size_t j;
+
+    for (j = 0; j < n; j++) {
+        if (data[j] != VCZ_INT_FILL && data[j] != VCZ_INT_MISSING) {
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool
+string_all_missing(const char *restrict data, size_t item_size, size_t n)
+{
+    size_t j;
+
+    for (j = 0; j < n * item_size; j++) {
+        if (data[j] != VCZ_STRING_FILL && data[j] != VCZ_STRING_MISSING) {
+            return false;
+        }
+    }
+    return true;
+}
+
 static int64_t
 string_field_write_entry(
     const vcz_field_t *self, const void *data, char *dest, size_t buflen, int64_t offset)
@@ -144,36 +170,46 @@ vcz_field_write(
     return vcz_field_write_entry(self, data, dest, buflen, offset);
 }
 
-void
-vcz_field_print_state(const vcz_field_t *self, FILE *out)
+static bool
+vcz_info_field_is_missing(const vcz_field_t *self, size_t variant)
 {
-    fprintf(out, "\t%s\ttype:%d\titem_size=%d\tnum_columns=%d\tdata=%p\n", self->name,
-        self->type, (int) self->item_size, (int) self->num_columns, self->data);
+
+    size_t row_size = self->num_columns * self->item_size;
+    const void *data = self->data + variant * row_size;
+
+    if (self->type == VCZ_TYPE_INT) {
+        if (self->item_size == 4) {
+            return int32_all_missing(data, self->num_columns);
+        }
+    } else if (self->type == VCZ_TYPE_STRING) {
+        return string_all_missing(data, self->item_size, self->num_columns);
+    }
+    assert(false);
+    return false;
 }
 
-int64_t
-vcz_variant_encoder_write_format_specifiers(
-    const vcz_variant_encoder_t *self, char *dest, size_t buflen, int64_t offset)
+static bool
+vcz_format_field_is_missing(const vcz_field_t *self, size_t variant, size_t num_samples)
 {
-    const int format_len = 7;
-    size_t j;
+    size_t row_size = self->num_columns * self->item_size * num_samples;
+    const void *data = self->data + variant * row_size;
 
-    strcpy(dest + offset, "FORMAT=");
-    offset += format_len;
-    if (self->gt.data != NULL) {
-        strcpy(dest + offset, "GT");
-        offset += 2;
-    }
-    for (j = 0; j < self->num_format_fields; j++) {
-        dest[offset] = ':';
-        offset++;
-        strcpy(dest + offset, self->format_fields[j].name);
-        offset += strlen(self->format_fields[j].name);
+    if (self->type == VCZ_TYPE_INT) {
+        if (self->item_size == 4) {
+            return int32_all_missing(data, self->num_columns * num_samples);
+        }
+    } else if (self->type == VCZ_TYPE_STRING) {
+        return string_all_missing(data, self->item_size, self->num_columns * num_samples);
     }
-    dest[offset] = '\t';
-    offset++;
-    dest[offset] = '\0';
-    return offset;
+    assert(false);
+    return false;
+}
+
+void
+vcz_field_print_state(const vcz_field_t *self, FILE *out)
+{
+    fprintf(out, "\t%s\ttype:%d\titem_size=%d\tnum_columns=%d\tdata=%p\n", self->name,
+        self->type, (int) self->item_size, (int) self->num_columns, self->data);
 }
 
 int64_t
@@ -219,98 +255,194 @@ vcz_variant_encoder_write_sample_gt(const vcz_variant_encoder_t *self, size_t va
     return offset;
 }
 
+/* int64_t */
+/* vcz_variant_encoder_write_format_fields(const vcz_variant_encoder_t *self, */
+/*     size_t variant, size_t sample, char *dest, size_t buflen, int64_t offset) */
+/* { */
+/*     vcz_field_t field; */
+/*     size_t j, row_size; */
+/*     const void *data; */
+
+/*     if (self->gt.data != NULL) { */
+/*         offset = vcz_variant_encoder_write_sample_gt( */
+/*             self, variant, sample, dest, buflen, offset); */
+/*         if (offset < 0) { */
+/*             goto out; */
+/*         } */
+/*     } */
+
+/*     for (j = 0; j < self->num_format_fields; j++) { */
+/*         field = self->format_fields[j]; */
+/*         dest[offset - 1] = ':'; */
+/*         row_size = self->num_samples * field.num_columns * field.item_size; */
+/*         data = field.data + variant * row_size */
+/*                + sample * field.num_columns * field.item_size; */
+/*         offset = vcz_field_write_entry(&field, data, dest, buflen, offset); */
+/*         if (offset < 0) { */
+/*             goto out; */
+/*         } */
+/*     } */
+/* out: */
+/*     return offset; */
+/* } */
+
 int64_t
-vcz_variant_encoder_write_format_fields(const vcz_variant_encoder_t *self,
-    size_t variant, size_t sample, char *dest, size_t buflen, int64_t offset)
+vcz_variant_encoder_write_info_fields(const vcz_variant_encoder_t *self, size_t variant,
+    char *dest, size_t buflen, int64_t offset)
 {
     vcz_field_t field;
-    size_t j, row_size;
-    const void *data;
-
-    if (self->gt.data != NULL) {
-        offset = vcz_variant_encoder_write_sample_gt(
-            self, variant, sample, dest, buflen, offset);
-        if (offset < 0) {
+    size_t j;
+    bool *missing = NULL;
+    bool all_missing = true;
+    bool first_field;
+
+    if (self->num_info_fields > 0) {
+        missing = malloc(self->num_info_fields * sizeof(*missing));
+        if (missing == NULL) {
+            offset = VCZ_ERR_NO_MEMORY;
             goto out;
         }
+        for (j = 0; j < self->num_info_fields; j++) {
+            missing[j] = vcz_info_field_is_missing(&self->info_fields[j], variant);
+            if (!missing[j]) {
+                all_missing = false;
+            }
+        }
     }
 
-    for (j = 0; j < self->num_format_fields; j++) {
-        field = self->format_fields[j];
-        dest[offset - 1] = ':';
-        row_size = self->num_samples * field.num_columns * field.item_size;
-        data = field.data + variant * row_size
-               + sample * field.num_columns * field.item_size;
-        offset = vcz_field_write_entry(&field, data, dest, buflen, offset);
-        if (offset < 0) {
-            goto out;
+    if (all_missing) {
+        dest[offset] = '.';
+        offset++;
+        dest[offset] = '\t';
+        offset++;
+    } else {
+        first_field = true;
+        for (j = 0; j < self->num_info_fields; j++) {
+            if (!missing[j]) {
+                if (!first_field) {
+                    dest[offset - 1] = ';';
+                }
+                first_field = false;
+                field = self->info_fields[j];
+                memcpy(dest + offset, field.name, field.name_length);
+                offset += field.name_length;
+                dest[offset] = '=';
+                offset++;
+                offset = vcz_field_write(&field, variant, dest, buflen, offset);
+                if (offset < 0) {
+                    goto out;
+                }
+            }
         }
     }
 out:
+    if (missing != NULL) {
+        free(missing);
+    }
     return offset;
 }
 
-int64_t
-vcz_variant_encoder_write_info_fields(const vcz_variant_encoder_t *self, size_t variant,
-    char *dest, size_t buflen, int64_t offset)
+
+static int64_t
+vcz_variant_encoder_write_format_fields(
+    const vcz_variant_encoder_t *self, size_t variant, char *buf, size_t buflen, int64_t offset)
 {
+    size_t j, sample, row_size;
     vcz_field_t field;
-    size_t j;
+    bool *missing = NULL;
+    bool all_missing = true;
+    bool has_gt = (self->gt.data != NULL);
+    bool gt_missing = true;
+    const size_t num_samples = self->num_samples;
+    const void *data;
 
-    if (self->num_info_fields == 0) {
-        dest[offset] = '.';
-        offset++;
-        dest[offset] = '\t';
-        offset++;
+    if (has_gt) {
+        gt_missing = vcz_format_field_is_missing(&self->gt, variant, num_samples);
     }
-    for (j = 0; j < self->num_info_fields; j++) {
-        if (j > 0) {
-            dest[offset - 1] = ';';
-        }
-        field = self->info_fields[j];
-        memcpy(dest + offset, field.name, field.name_length);
-        offset += field.name_length;
-        dest[offset] = '=';
-        offset++;
-        offset = vcz_field_write(&field, variant, dest, buflen, offset);
-        if (offset < 0) {
+
+    if (self->num_format_fields > 0) {
+        missing = malloc(self->num_format_fields * sizeof(*missing));
+        if (missing == NULL) {
+            offset = VCZ_ERR_NO_MEMORY;
             goto out;
         }
+        for (j = 0; j < self->num_format_fields; j++) {
+            missing[j] = vcz_format_field_is_missing(&self->format_fields[j], variant, num_samples);
+            if (!missing[j]) {
+                all_missing = false;
+            }
+        }
+    }
+    all_missing = all_missing && gt_missing;
+
+    if (! all_missing) {
+
+        if (!gt_missing) {
+            strcpy(buf + offset, "GT:");
+            offset += 3;
+        }
+        for (j = 0; j < self->num_format_fields; j++) {
+            if (!missing[j]) {
+                strcpy(buf + offset, self->format_fields[j].name);
+                offset += self->format_fields[j].name_length;
+                buf[offset] = ':';
+                offset++;
+            }
+        }
+        buf[offset - 1] = '\t';
+
+        for (sample = 0; sample < num_samples; sample++) {
+            if (!gt_missing) {
+                offset = vcz_variant_encoder_write_sample_gt(
+                    self, variant, sample, buf, buflen, offset);
+                if (offset < 0) {
+                    goto out;
+                }
+                buf[offset - 1] = ':';
+            }
+            for (j = 0; j < self->num_format_fields; j++) {
+                if (!missing[j]) {
+                    field = self->format_fields[j];
+                    row_size = num_samples * field.num_columns * field.item_size;
+                    data = field.data + variant * row_size
+                           + sample * field.num_columns * field.item_size;
+                    offset = vcz_field_write_entry(&field, data, buf, buflen, offset);
+                    if (offset < 0) {
+                        goto out;
+                    }
+                    buf[offset - 1] = ':';
+                }
+            }
+            buf[offset - 1] = '\t';
+        }
     }
 out:
+    if (missing != NULL) {
+        free(missing);
+    }
     return offset;
 }
 
 int64_t
 vcz_variant_encoder_write_row(
-    const vcz_variant_encoder_t *self, size_t row, char *buf, size_t buflen)
+    const vcz_variant_encoder_t *self, size_t variant, char *buf, size_t buflen)
 {
     int64_t offset = 0;
     size_t j;
 
     for (j = 0; j < VCZ_NUM_FIXED_FIELDS; j++) {
-        offset = vcz_field_write(&self->fixed_fields[j], row, buf, buflen, offset);
+        offset = vcz_field_write(&self->fixed_fields[j], variant, buf, buflen, offset);
         if (offset < 0) {
             goto out;
         }
     }
-    offset = vcz_variant_encoder_write_info_fields(self, row, buf, buflen, offset);
+    offset = vcz_variant_encoder_write_info_fields(self, variant, buf, buflen, offset);
     if (offset < 0) {
         goto out;
     }
-    if (self->num_samples > 0) {
-        offset = vcz_variant_encoder_write_format_specifiers(self, buf, buflen, offset);
-        if (offset < 0) {
-            goto out;
-        }
-        for (j = 0; j < self->num_samples; j++) {
-            /* printf("Run sample %d\n", (int) j); */
-            offset = vcz_variant_encoder_write_format_fields(
-                self, row, j, buf, buflen, offset);
-            if (offset < 0) {
-                goto out;
-            }
-        }
+    offset = vcz_variant_encoder_write_format_fields(self, variant, buf, buflen, offset);
+    if (offset < 0) {
+        goto out;
     }
     offset--;
     buf[offset] = '\0';

lib/vcf_encoder.h

@@ -4,6 +4,8 @@
 
 #define VCZ_INT_MISSING -1
 #define VCZ_INT_FILL -2
+#define VCZ_STRING_MISSING '.'
+#define VCZ_STRING_FILL '\0'
 
 #define VCZ_NUM_FIXED_FIELDS 7