constify rest of public C API and tsk_tree_t types

c/dev-tools/dev-cli.c

@@ -249,7 +249,7 @@ run_simplify(const char *input_filename,
     int verbose)
 {
     tsk_treeseq_t ts, subset;
-    tsk_id_t *samples;
+    const tsk_id_t *samples;
     int flags = 0;
     int ret;
 

c/examples/tree_traversal.c

@@ -65,7 +65,7 @@ traverse_stack(tsk_tree_t *tree)
 static void
 traverse_upwards(tsk_tree_t *tree)
 {
-    tsk_id_t *samples = tsk_treeseq_get_samples(tree->tree_sequence);
+    const tsk_id_t *samples = tsk_treeseq_get_samples(tree->tree_sequence);
     tsk_size_t num_samples = tsk_treeseq_get_num_samples(tree->tree_sequence);
     tsk_size_t j;
     tsk_id_t u;

c/tests/test_stats.c

@@ -217,8 +217,8 @@ static void
 verify_genealogical_nearest_neighbours(tsk_treeseq_t *ts)
 {
     int ret;
-    tsk_id_t *samples;
-    tsk_id_t *sample_sets[2];
+    const tsk_id_t *samples;
+    const tsk_id_t *sample_sets[2];
     size_t sample_set_size[2];
     size_t num_samples = tsk_treeseq_get_num_samples(ts);
     double *A = malloc(2 * num_samples * sizeof(double));
@@ -257,13 +257,14 @@ verify_mean_descendants(tsk_treeseq_t *ts)
 {
     int ret;
     tsk_id_t *samples;
-    tsk_id_t *sample_sets[2];
+    const tsk_id_t *sample_sets[2];
     size_t sample_set_size[2];
     size_t num_samples = tsk_treeseq_get_num_samples(ts);
     double *C = malloc(2 * tsk_treeseq_get_num_nodes(ts) * sizeof(double));
     CU_ASSERT_FATAL(C != NULL);
 
-    samples = tsk_treeseq_get_samples(ts);
+    samples = malloc(num_samples * sizeof(*samples));
+    memcpy(samples, tsk_treeseq_get_samples(ts), num_samples * sizeof(*samples));
 
     sample_sets[0] = samples;
     sample_set_size[0] = num_samples / 2;
@@ -283,6 +284,7 @@ verify_mean_descendants(tsk_treeseq_t *ts)
     ret = tsk_treeseq_mean_descendants(ts, sample_sets, sample_set_size, 2, 0, C);
     CU_ASSERT_EQUAL_FATAL(ret, TSK_ERR_NODE_OUT_OF_BOUNDS);
 
+    free(samples);
     free(C);
 }
 
@@ -818,7 +820,7 @@ verify_afs(tsk_treeseq_t *ts)
     int ret;
     tsk_size_t n = tsk_treeseq_get_num_samples(ts);
     tsk_size_t sample_set_sizes[2];
-    tsk_id_t *samples = tsk_treeseq_get_samples(ts);
+    const tsk_id_t *samples = tsk_treeseq_get_samples(ts);
     double *result = malloc(n * n * sizeof(*result));
 
     CU_ASSERT_FATAL(sample_set_sizes != NULL);

c/tests/test_trees.c

@@ -181,7 +181,7 @@ verify_trees(tsk_treeseq_t *ts, tsk_size_t num_trees, tsk_id_t *parents)
     tsk_id_t u, j, v;
     uint32_t mutation_index, site_index;
     tsk_size_t k, l, tree_sites_length;
-    tsk_site_t *sites = NULL;
+    const tsk_site_t *sites = NULL;
     tsk_tree_t tree;
     size_t num_nodes = tsk_treeseq_get_num_nodes(ts);
     size_t num_sites = tsk_treeseq_get_num_sites(ts);
@@ -474,16 +474,16 @@ verify_tree_diffs(tsk_treeseq_t *ts, tsk_flags_t options)
 /* When we keep all sites in simplify, the genotypes for the subset of the
  * samples should be the same as the original */
 static void
-verify_simplify_genotypes(
-    tsk_treeseq_t *ts, tsk_treeseq_t *subset, tsk_id_t *samples, size_t num_samples)
+verify_simplify_genotypes(tsk_treeseq_t *ts, tsk_treeseq_t *subset,
+    const tsk_id_t *samples, size_t num_samples)
 {
     int ret;
     size_t m = tsk_treeseq_get_num_sites(ts);
     tsk_vargen_t vargen, subset_vargen;
     tsk_variant_t *variant, *subset_variant;
     size_t j, k;
     int8_t a1, a2;
-    tsk_id_t *sample_index_map;
+    const tsk_id_t *sample_index_map;
 
     sample_index_map = tsk_treeseq_get_sample_index_map(ts);
 
@@ -529,13 +529,13 @@ verify_simplify_genotypes(
 }
 
 static void
-verify_simplify_properties(tsk_treeseq_t *ts, tsk_treeseq_t *subset, tsk_id_t *samples,
-    size_t num_samples, tsk_id_t *node_map)
+verify_simplify_properties(tsk_treeseq_t *ts, tsk_treeseq_t *subset,
+    const tsk_id_t *samples, size_t num_samples, tsk_id_t *node_map)
 {
     int ret;
     tsk_node_t n1, n2;
     tsk_tree_t full_tree, subset_tree;
-    tsk_site_t *tree_sites;
+    const tsk_site_t *tree_sites;
     tsk_size_t tree_sites_length;
     uint32_t j, k;
     tsk_id_t u, mrca1, mrca2;
@@ -647,7 +647,7 @@ verify_simplify(tsk_treeseq_t *ts)
     tsk_size_t n = tsk_treeseq_get_num_samples(ts);
     tsk_size_t num_samples[] = { 0, 1, 2, 3, n / 2, n - 1, n };
     tsk_size_t j;
-    tsk_id_t *sample;
+    const tsk_id_t *sample;
     tsk_id_t *node_map = malloc(tsk_treeseq_get_num_nodes(ts) * sizeof(tsk_id_t));
     tsk_treeseq_t subset;
     tsk_flags_t options = TSK_FILTER_SITES;
@@ -695,7 +695,7 @@ verify_sample_counts(tsk_treeseq_t *ts, size_t num_tests, sample_count_test_t *t
     size_t j, num_samples, n, k;
     tsk_id_t stop, sample_index;
     tsk_tree_t tree;
-    tsk_id_t *samples;
+    const tsk_id_t *samples;
 
     n = tsk_treeseq_get_num_samples(ts);
     samples = tsk_treeseq_get_samples(ts);
@@ -822,7 +822,7 @@ verify_sample_sets_for_tree(tsk_tree_t *tree)
     tsk_id_t u, v;
     size_t tmp, n, num_nodes, num_samples;
     tsk_id_t *stack, *samples;
-    tsk_treeseq_t *ts = tree->tree_sequence;
+    const tsk_treeseq_t *ts = tree->tree_sequence;
     tsk_id_t *sample_index_map = ts->sample_index_map;
     const tsk_id_t *list_left = tree->left_sample;
     const tsk_id_t *list_right = tree->right_sample;
@@ -1402,8 +1402,8 @@ test_simplest_general_samples(void)
                         "0.75 0\n";
     const char *mutations = "0    2     1\n"
                             "1    0     1";
-    tsk_id_t samples[2] = { 0, 2 };
-    tsk_id_t *s;
+    const tsk_id_t samples[2] = { 0, 2 };
+    const tsk_id_t *s;
     int ret;
 
     tsk_treeseq_t ts, simplified;
@@ -3577,7 +3577,7 @@ test_single_tree_general_samples_iter(void)
                         "0  6   1   5,6\n"
                         "0  6   0   1,2\n";
     tsk_id_t parents[] = { TSK_NULL, 0, 0, 2, 2, 1, 1 };
-    tsk_id_t *samples;
+    const tsk_id_t *samples;
     tsk_treeseq_t ts;
     tsk_tree_t tree;
     tsk_id_t u, v, w;
@@ -5351,7 +5351,7 @@ test_genealogical_nearest_neighbours_errors(void)
 {
     int ret;
     tsk_treeseq_t ts;
-    tsk_id_t *reference_sets[2];
+    const tsk_id_t *reference_sets[2];
     tsk_id_t reference_set_0[4], reference_set_1[4];
     tsk_id_t focal[] = { 0, 1, 2, 3 };
     size_t reference_set_size[2];

c/tskit/convert.c

@@ -46,15 +46,15 @@ typedef struct {
     tsk_flags_t options;
     char *newick;
     tsk_id_t *traversal_stack;
-    tsk_tree_t *tree;
+    const tsk_tree_t *tree;
 } tsk_newick_converter_t;
 
 static int
 tsk_newick_converter_run(
     tsk_newick_converter_t *self, tsk_id_t root, size_t buffer_size, char *buffer)
 {
     int ret = TSK_ERR_GENERIC;
-    tsk_tree_t *tree = self->tree;
+    const tsk_tree_t *tree = self->tree;
     tsk_id_t *stack = self->traversal_stack;
     const double *time = self->tree->tree_sequence->tables->nodes.time;
     int stack_top = 0;
@@ -144,7 +144,7 @@ tsk_newick_converter_run(
 }
 
 static int
-tsk_newick_converter_init(tsk_newick_converter_t *self, tsk_tree_t *tree,
+tsk_newick_converter_init(tsk_newick_converter_t *self, const tsk_tree_t *tree,
     size_t precision, tsk_flags_t options)
 {
     int ret = 0;
@@ -171,7 +171,7 @@ tsk_newick_converter_free(tsk_newick_converter_t *self)
 }
 
 int
-tsk_convert_newick(tsk_tree_t *tree, tsk_id_t root, size_t precision,
+tsk_convert_newick(const tsk_tree_t *tree, tsk_id_t root, size_t precision,
     tsk_flags_t options, size_t buffer_size, char *buffer)
 {
     int ret = 0;

c/tskit/convert.h

@@ -32,7 +32,7 @@ extern "C" {
 
 #include <tskit/trees.h>
 
-int tsk_convert_newick(tsk_tree_t *tree, tsk_id_t root, size_t precision,
+int tsk_convert_newick(const tsk_tree_t *tree, tsk_id_t root, size_t precision,
     tsk_flags_t options, size_t buffer_size, char *buffer);
 
 #ifdef __cplusplus

c/tskit/genotypes.c

@@ -35,7 +35,7 @@
  * ======================================================== */
 
 void
-tsk_vargen_print_state(tsk_vargen_t *self, FILE *out)
+tsk_vargen_print_state(const tsk_vargen_t *self, FILE *out)
 {
     tsk_size_t j;
 
@@ -102,60 +102,77 @@ tsk_vargen_copy_alleles(tsk_vargen_t *self, const char **alleles)
     return ret;
 }
 
+static int
+vargen_init_samples_and_index_map(tsk_vargen_t *self, const tsk_treeseq_t *tree_sequence,
+    const tsk_id_t *samples, size_t num_samples, size_t num_samples_alloc,
+    tsk_flags_t options)
+{
+    int ret = 0;
+    const tsk_flags_t *flags = tree_sequence->tables->nodes.flags;
+    size_t j, num_nodes;
+    bool impute_missing = !!(options & TSK_ISOLATED_NOT_MISSING);
+    tsk_id_t u;
+
+    num_nodes = tsk_treeseq_get_num_nodes(tree_sequence);
+    self->alt_samples = malloc(num_samples_alloc * sizeof(*samples));
+    self->alt_sample_index_map = malloc(num_nodes * sizeof(*self->alt_sample_index_map));
+    if (self->alt_samples == NULL || self->alt_sample_index_map == NULL) {
+        ret = TSK_ERR_NO_MEMORY;
+        goto out;
+    }
+    memcpy(self->alt_samples, samples, num_samples * sizeof(*samples));
+    memset(self->alt_sample_index_map, 0xff,
+        num_nodes * sizeof(*self->alt_sample_index_map));
+    /* Create the reverse mapping */
+    for (j = 0; j < num_samples; j++) {
+        u = samples[j];
+        if (u < 0 || u >= (tsk_id_t) num_nodes) {
+            ret = TSK_ERR_OUT_OF_BOUNDS;
+            goto out;
+        }
+        if (self->alt_sample_index_map[u] != TSK_NULL) {
+            ret = TSK_ERR_DUPLICATE_SAMPLE;
+            goto out;
+        }
+        /* We can only detect missing data for samples */
+        if (!impute_missing && !(flags[u] & TSK_NODE_IS_SAMPLE)) {
+            ret = TSK_ERR_MUST_IMPUTE_NON_SAMPLES;
+            goto out;
+        }
+        self->alt_sample_index_map[samples[j]] = (tsk_id_t) j;
+    }
+out:
+    return ret;
+}
+
 int
-tsk_vargen_init(tsk_vargen_t *self, tsk_treeseq_t *tree_sequence, tsk_id_t *samples,
-    size_t num_samples, const char **alleles, tsk_flags_t options)
+tsk_vargen_init(tsk_vargen_t *self, const tsk_treeseq_t *tree_sequence,
+    const tsk_id_t *samples, size_t num_samples, const char **alleles,
+    tsk_flags_t options)
 {
     int ret = TSK_ERR_NO_MEMORY;
     tsk_flags_t tree_options;
-    const tsk_flags_t *flags = tree_sequence->tables->nodes.flags;
-    size_t j, num_nodes, num_samples_alloc, max_alleles_limit;
-    bool impute_missing = !!(options & TSK_ISOLATED_NOT_MISSING);
+    size_t num_samples_alloc, max_alleles_limit;
     tsk_size_t max_alleles;
-    tsk_id_t u;
 
     tsk_bug_assert(tree_sequence != NULL);
     memset(self, 0, sizeof(tsk_vargen_t));
 
     if (samples == NULL) {
-        self->sample_index_map_allocated = false;
         self->num_samples = tsk_treeseq_get_num_samples(tree_sequence);
         self->sample_index_map = tsk_treeseq_get_sample_index_map(tree_sequence);
         num_samples_alloc = self->num_samples;
     } else {
-        self->sample_index_map_allocated = true;
         /* Take a copy of the samples for simplicity */
-        num_nodes = tsk_treeseq_get_num_nodes(tree_sequence);
         /* We can have num_samples = 0 here, so guard against malloc(0) */
         num_samples_alloc = num_samples + 1;
-        self->samples = malloc(num_samples_alloc * sizeof(*self->samples));
-        self->sample_index_map = malloc(num_nodes * sizeof(*self->sample_index_map));
-        if (self->samples == NULL || self->sample_index_map == NULL) {
-            ret = TSK_ERR_NO_MEMORY;
+        ret = vargen_init_samples_and_index_map(
+            self, tree_sequence, samples, num_samples, num_samples_alloc, options);
+        if (ret != 0) {
             goto out;
         }
-        memcpy(self->samples, samples, num_samples * sizeof(*self->samples));
-        memset(
-            self->sample_index_map, 0xff, num_nodes * sizeof(*self->sample_index_map));
-        /* Create the reverse mapping */
-        for (j = 0; j < num_samples; j++) {
-            u = samples[j];
-            if (u < 0 || u >= (tsk_id_t) num_nodes) {
-                ret = TSK_ERR_OUT_OF_BOUNDS;
-                goto out;
-            }
-            if (self->sample_index_map[u] != TSK_NULL) {
-                ret = TSK_ERR_DUPLICATE_SAMPLE;
-                goto out;
-            }
-            /* We can only detect missing data for samples */
-            if (!impute_missing && !(flags[u] & TSK_NODE_IS_SAMPLE)) {
-                ret = TSK_ERR_MUST_IMPUTE_NON_SAMPLES;
-                goto out;
-            }
-            self->sample_index_map[samples[j]] = (tsk_id_t) j;
-        }
         self->num_samples = num_samples;
+        self->sample_index_map = self->alt_sample_index_map;
     }
     self->num_sites = tsk_treeseq_get_num_sites(tree_sequence);
     self->tree_sequence = tree_sequence;
@@ -207,7 +224,7 @@ tsk_vargen_init(tsk_vargen_t *self, tsk_treeseq_t *tree_sequence, tsk_id_t *samp
     /* When a list of samples is given, we use the traversal based algorithm
      * and turn off the sample list tracking in the tree */
     tree_options = 0;
-    if (self->samples == NULL) {
+    if (self->alt_samples == NULL) {
         tree_options = TSK_SAMPLE_LISTS;
     } else {
         self->traversal_stack = malloc(
@@ -241,11 +258,9 @@ tsk_vargen_free(tsk_vargen_t *self)
     tsk_safe_free(self->variant.alleles);
     tsk_safe_free(self->variant.allele_lengths);
     tsk_safe_free(self->user_alleles_mem);
-    tsk_safe_free(self->samples);
+    tsk_safe_free(self->alt_samples);
+    tsk_safe_free(self->alt_sample_index_map);
     tsk_safe_free(self->traversal_stack);
-    if (self->sample_index_map_allocated) {
-        tsk_safe_free(self->sample_index_map);
-    }
     return 0;
 }
 
@@ -516,11 +531,11 @@ tsk_vargen_update_site(tsk_vargen_t *self)
     tsk_size_t j, num_missing;
     int no_longer_missing;
     tsk_variant_t *var = &self->variant;
-    tsk_site_t *site = var->site;
+    const tsk_site_t *site = var->site;
     tsk_mutation_t mutation;
     bool genotypes16 = !!(self->options & TSK_16_BIT_GENOTYPES);
     bool impute_missing = !!(self->options & TSK_ISOLATED_NOT_MISSING);
-    bool by_traversal = self->samples != NULL;
+    bool by_traversal = self->alt_samples != NULL;
     int (*update_genotypes)(tsk_vargen_t *, tsk_id_t, tsk_id_t);
     tsk_size_t (*mark_missing)(tsk_vargen_t *);