phew

Author: molpopgen

src/sys/flags.rs

@@ -117,30 +117,35 @@ pub struct SimplificationOptions(RawFlags);
 
 impl SimplificationOptions {
     /// Default behavior
-    pub const NONE: RawFlags = 0;
-    pub const FILTER_SITES: RawFlags = ll_bindings::TSK_SIMPLIFY_FILTER_SITES;
+    pub const NONE: Self = Self(0);
+    make_constant_self!(=> FILTER_SITES, TSK_SIMPLIFY_FILTER_SITES);
+    make_constant_self!(
     /// If True, remove any populations that are not referenced by
     /// nodes after simplification; new population IDs are allocated
     /// sequentially from zero.
     /// If False, the population table will not be altered in any way.
-    pub const FILTER_POPULATIONS: RawFlags = ll_bindings::TSK_SIMPLIFY_FILTER_POPULATIONS;
+        => FILTER_POPULATIONS, TSK_SIMPLIFY_FILTER_POPULATIONS);
+    make_constant_self!(
     /// If True, remove any individuals that are not referenced by nodes
     /// after simplification; new individual IDs are allocated sequentially
     /// from zero. If False, the individual table will not be altered in any way.
-    pub const FILTER_INDIVIDUALS: RawFlags = ll_bindings::TSK_SIMPLIFY_FILTER_INDIVIDUALS;
+    => FILTER_INDIVIDUALS,TSK_SIMPLIFY_FILTER_INDIVIDUALS);
+    make_constant_self!(
     /// Whether to reduce the topology down to the trees that are present at sites.
-    pub const REDUCE_TO_SITE_TOPOLOGY: RawFlags = ll_bindings::TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY;
+    => REDUCE_TO_SITE_TOPOLOGY,TSK_SIMPLIFY_REDUCE_TO_SITE_TOPOLOGY);
+    make_constant_self!(
     /// If True, preserve unary nodes (i.e. nodes with exactly one child)
     /// that exist on the path from samples to root.
-    pub const KEEP_UNARY: RawFlags = ll_bindings::TSK_SIMPLIFY_KEEP_UNARY;
+    => KEEP_UNARY,TSK_SIMPLIFY_KEEP_UNARY);
+    make_constant_self!(
     /// Whether to retain history ancestral to the MRCA of the samples.
-    pub const KEEP_INPUT_ROOTS: RawFlags = ll_bindings::TSK_SIMPLIFY_KEEP_INPUT_ROOTS;
+    => KEEP_INPUT_ROOTS, TSK_SIMPLIFY_KEEP_INPUT_ROOTS);
+    make_constant_self!(
     ///  If True, preserve unary nodes that exist on the path from samples
     ///  to root, but only if they are associated with an individual
     ///  in the individuals table.
     ///  Cannot be specified at the same time as `KEEP_UNARY`.
-    pub const KEEP_UNARY_IN_INDIVIDUALS: RawFlags =
-        ll_bindings::TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS;
+    => KEEP_UNARY_IN_INDIVIDUALS,TSK_SIMPLIFY_KEEP_UNARY_IN_INDIVIDUALS);
 
     flag_builder_api!(
     /// Update to set [`KEEP_INPUT_ROOTS`](crate::SimplificationOptions::KEEP_INPUT_ROOTS).
@@ -278,10 +283,10 @@ pub struct TableClearOptions(RawFlags);
 
 impl TableClearOptions {
     /// Default behavior.
-    pub const NONE: RawFlags = 0;
-    pub const CLEAR_METADATA_SCHEMAS: RawFlags = ll_bindings::TSK_CLEAR_METADATA_SCHEMAS;
-    pub const CLEAR_TS_METADATA_SCHEMA: RawFlags = ll_bindings::TSK_CLEAR_TS_METADATA_AND_SCHEMA;
-    pub const CLEAR_PROVENANCE: RawFlags = ll_bindings::TSK_CLEAR_PROVENANCE;
+    pub const NONE: Self = Self(0);
+    make_constant_self!(=> CLEAR_METADATA_SCHEMAS,TSK_CLEAR_METADATA_SCHEMAS);
+    make_constant_self!(=> CLEAR_TS_METADATA_SCHEMA, TSK_CLEAR_TS_METADATA_AND_SCHEMA);
+    make_constant_self!(=> CLEAR_PROVENANCE,TSK_CLEAR_PROVENANCE);
     flag_builder_api!(
         /// Set [`CLEAR_METADATA_SCHEMAS`](crate::TableClearOptions::CLEAR_METADATA_SCHEMAS)
         => clear_metadata_schema, CLEAR_METADATA_SCHEMAS);
@@ -351,11 +356,11 @@ pub struct TableEqualityOptions(RawFlags);
 
 impl TableEqualityOptions {
     /// Default behavior.
-    pub const NONE: RawFlags = 0;
-    pub const IGNORE_METADATA: RawFlags = ll_bindings::TSK_CMP_IGNORE_METADATA;
-    pub const IGNORE_TS_METADATA: RawFlags = ll_bindings::TSK_CMP_IGNORE_TS_METADATA;
-    pub const IGNORE_PROVENANCE: RawFlags = ll_bindings::TSK_CMP_IGNORE_PROVENANCE;
-    pub const IGNORE_TIMESTAMPS: RawFlags = ll_bindings::TSK_CMP_IGNORE_TIMESTAMPS;
+    pub const NONE: Self = Self(0);
+    make_constant_self!(=> IGNORE_METADATA,TSK_CMP_IGNORE_METADATA);
+    make_constant_self!(=>IGNORE_TS_METADATA, TSK_CMP_IGNORE_TS_METADATA);
+    make_constant_self!(=> IGNORE_PROVENANCE,TSK_CMP_IGNORE_PROVENANCE);
+    make_constant_self!(=> IGNORE_TIMESTAMPS,TSK_CMP_IGNORE_TIMESTAMPS);
     flag_builder_api!(
         /// Set [`IGNORE_METADATA`](crate::TableEqualityOptions::IGNORE_METADATA)
         => ignore_metadata, IGNORE_METADATA);
@@ -400,9 +405,10 @@ pub struct TableSortOptions(RawFlags);
 
 impl TableSortOptions {
     /// Default behavior.
-    pub const NONE: RawFlags = 0;
+    pub const NONE: Self = Self(0);
+    make_constant_self!(
     /// Do not validate contents of edge table.
-    pub const NO_CHECK_INTEGRITY: RawFlags = ll_bindings::TSK_NO_CHECK_INTEGRITY;
+    => NO_CHECK_INTEGRITY, TSK_NO_CHECK_INTEGRITY);
     flag_builder_api!(
         /// Set [`NO_CHECK_INTEGRITY`](crate::TableSortOptions::NO_CHECK_INTEGRITY)
         => no_check_integrity, NO_CHECK_INTEGRITY);
@@ -428,7 +434,7 @@ pub struct IndividualTableSortOptions(RawFlags);
 
 impl IndividualTableSortOptions {
     /// Default behavior.
-    pub const NONE: RawFlags = 0;
+    pub const NONE: Self = Self(0);
     bits!();
     all!();
     contains!();
@@ -468,13 +474,15 @@ pub struct TreeFlags(RawFlags);
 
 impl TreeFlags {
     /// Default behavior.
-    pub const NONE: RawFlags = 0;
+    pub const NONE: Self = Self(0);
+    make_constant_self!(
     /// Update sample lists, enabling [`Tree::samples`].
-    pub const SAMPLE_LISTS: RawFlags = ll_bindings::TSK_SAMPLE_LISTS;
+    => SAMPLE_LISTS,TSK_SAMPLE_LISTS);
+    make_constant_self!(
     /// Do *not* update the number of samples descending
     /// from each node. The default is to update these
     /// counts.
-    pub const NO_SAMPLE_COUNTS: RawFlags = ll_bindings::TSK_NO_SAMPLE_COUNTS;
+    => NO_SAMPLE_COUNTS,TSK_NO_SAMPLE_COUNTS);
     flag_builder_api!(
         /// Set [`SAMPLE_LISTS`](crate::TreeFlags::SAMPLE_LISTS)
         => sample_lists, SAMPLE_LISTS);
@@ -545,9 +553,10 @@ pub struct TreeSequenceFlags(RawFlags);
 
 impl TreeSequenceFlags {
     /// Default behavior
-    pub const NONE: RawFlags = 0;
+    pub const NONE: Self = Self(0);
+    make_constant_self!(
     /// If used, then build table indexes if they are not present.
-    pub const BUILD_INDEXES: RawFlags = ll_bindings::TSK_TS_INIT_BUILD_INDEXES;
+    => BUILD_INDEXES, TSK_TS_INIT_BUILD_INDEXES);
     flag_builder_api!(
         /// Set [`BUILD_INDEXES`](crate::TreeSequenceFlags::BUILD_INDEXES)
         => build_indexes, BUILD_INDEXES);
@@ -626,23 +635,31 @@ pub struct TableIntegrityCheckFlags(RawFlags);
 
 impl TableIntegrityCheckFlags {
     /// Default behavior is a set of basic checks
-    pub const NONE: RawFlags = 0;
+    pub const NONE: Self = Self(0);
+    make_constant_self!(
     /// Check that edges are ordered
-    pub const CHECK_EDGE_ORDERING: RawFlags = ll_bindings::TSK_CHECK_EDGE_ORDERING;
+     => CHECK_EDGE_ORDERING, TSK_CHECK_EDGE_ORDERING);
+    make_constant_self!(
     /// Check that sites are ordered
-    pub const CHECK_SITE_ORDERING: RawFlags = ll_bindings::TSK_CHECK_SITE_ORDERING;
+    => CHECK_SITE_ORDERING, TSK_CHECK_SITE_ORDERING);
+    make_constant_self!(
     /// Check for duplicated sites
-    pub const CHECK_SITE_DUPLICATES: RawFlags = ll_bindings::TSK_CHECK_SITE_DUPLICATES;
+    => CHECK_SITE_DUPLICATES, TSK_CHECK_SITE_DUPLICATES);
+    make_constant_self!(
     /// Check that mutations are ordered
-    pub const CHECK_MUTATION_ORDERING: RawFlags = ll_bindings::TSK_CHECK_MUTATION_ORDERING;
+    => CHECK_MUTATION_ORDERING, TSK_CHECK_MUTATION_ORDERING);
+    make_constant_self!(
     /// Check that individuals are ordered
-    pub const CHECK_INDIVIDUAL_ORDERING: RawFlags = ll_bindings::TSK_CHECK_INDIVIDUAL_ORDERING;
+    => CHECK_INDIVIDUAL_ORDERING, TSK_CHECK_INDIVIDUAL_ORDERING);
+    make_constant_self!(
     /// Check that migrations are ordered
-    pub const CHECK_MIGRATION_ORDERING: RawFlags = ll_bindings::TSK_CHECK_MIGRATION_ORDERING;
+    => CHECK_MIGRATION_ORDERING, TSK_CHECK_MIGRATION_ORDERING);
+    make_constant_self!(
     /// Check that table indexes are valid
-    pub const CHECK_INDEXES: RawFlags = ll_bindings::TSK_CHECK_INDEXES;
+    => CHECK_INDEXES, TSK_CHECK_INDEXES);
+    make_constant_self!(
     /// Check tree integrity.  Enables most or all of the preceding options.
-    pub const CHECK_TREES: RawFlags = ll_bindings::TSK_CHECK_TREES;
+    => CHECK_TREES, TSK_CHECK_TREES);
     flag_builder_api!(
         /// Set [`CHECK_EDGE_ORDERING`](crate::TableIntegrityCheckFlags::CHECK_EDGE_ORDERING)
         => check_edge_ordering, CHECK_EDGE_ORDERING);
@@ -741,7 +758,7 @@ pub struct IndividualFlags(RawFlags);
 
 impl IndividualFlags {
     /// Default (empty)
-    pub const NONE: RawFlags = 0;
+    pub const NONE: Self = Self(0);
     /// We do not enforce valid flags in the library.
     /// This function will return `true` if any bits
     /// are set that do not correspond to allowed flags.