Skip to content

Commit 6097b39

Browse files
molpopgenmolpopgen
committed
start on a redesign
1 parent f0825ab commit 6097b39

File tree

4 files changed

+164
-125
lines changed

4 files changed

+164
-125
lines changed

‎src/edge_table.rs‎

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -358,21 +358,21 @@ impl EdgeTable {
358358
/// Get the child column as a slice of the underlying integer type
359359
=> child, child_slice_raw, ll_bindings::tsk_id_t);
360360

361-
pub fn parent_column(&self) -> crate::EdgeTableColumn<crate::NodeId> {
362-
crate::EdgeTableColumn::new(self.parent_slice())
361+
pub fn parent_column(&self) -> impl crate::table_column::TableColumn<EdgeId, NodeId> + '_ {
362+
crate::table_column::OpaqueTableColumn(self.parent_slice())
363363
}
364364

365-
pub fn child_column(&self) -> crate::EdgeTableColumn<crate::NodeId> {
366-
crate::EdgeTableColumn::new(self.child_slice())
367-
}
365+
//pub fn child_column(&self) -> crate::EdgeTableColumn<crate::NodeId> {
366+
// crate::EdgeTableColumn::new(self.child_slice())
367+
//}
368368

369-
pub fn left_column(&self) -> crate::EdgeTableColumn<Position> {
370-
crate::EdgeTableColumn::new(self.left_slice())
371-
}
369+
//pub fn left_column(&self) -> crate::EdgeTableColumn<Position> {
370+
// crate::EdgeTableColumn::new(self.left_slice())
371+
//}
372372

373-
pub fn right_column(&self) -> crate::EdgeTableColumn<Position> {
374-
crate::EdgeTableColumn::new(self.right_slice())
375-
}
373+
//pub fn right_column(&self) -> crate::EdgeTableColumn<Position> {
374+
// crate::EdgeTableColumn::new(self.right_slice())
375+
//}
376376

377377
/// Clear all data from the table
378378
pub fn clear(&mut self) -> Result<i32, TskitError> {

‎src/lib.rs‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -117,7 +117,6 @@ pub use site_table::{SiteTable, SiteTableRow};
117117
pub use sys::flags::*;
118118
pub use sys::NodeTraversalOrder;
119119
pub use table_collection::TableCollection;
120-
pub use table_column::{EdgeTableColumn, NodeTableColumn};
121120
pub use traits::IndividualLocation;
122121
pub use traits::IndividualParents;
123122
pub use trees::{Tree, TreeSequence};

‎src/node_table.rs‎

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -807,21 +807,21 @@ impl NodeTable {
807807
/// Get the population column as a slice
808808
=> population, population_slice_raw, crate::sys::bindings::tsk_id_t);
809809

810-
pub fn individual_column(&self) -> crate::table_column::NodeTableColumn<IndividualId> {
811-
crate::NodeTableColumn::new(self.individual_slice())
812-
}
810+
//pub fn individual_column(&self) -> crate::table_column::NodeTableColumn<IndividualId> {
811+
// crate::NodeTableColumn::new(self.individual_slice())
812+
//}
813813

814-
pub fn population_column(&self) -> crate::NodeTableColumn<PopulationId> {
815-
crate::NodeTableColumn::new(self.population_slice())
816-
}
814+
//pub fn population_column(&self) -> crate::NodeTableColumn<PopulationId> {
815+
// crate::NodeTableColumn::new(self.population_slice())
816+
//}
817817

818-
pub fn time_column(&self) -> crate::NodeTableColumn<Time> {
819-
crate::NodeTableColumn::new(self.time_slice())
820-
}
818+
//pub fn time_column(&self) -> crate::NodeTableColumn<Time> {
819+
// crate::NodeTableColumn::new(self.time_slice())
820+
//}
821821

822-
pub fn flags_column(&self) -> crate::NodeTableColumn<NodeFlags> {
823-
crate::NodeTableColumn::new(self.flags_slice())
824-
}
822+
//pub fn flags_column(&self) -> crate::NodeTableColumn<NodeFlags> {
823+
// crate::NodeTableColumn::new(self.flags_slice())
824+
//}
825825

826826
/// Clear all data from the table
827827
pub fn clear(&mut self) -> Result<i32, TskitError> {

‎src/table_column.rs‎

Lines changed: 141 additions & 101 deletions
Original file line numberDiff line numberDiff line change
@@ -1,113 +1,153 @@
1-
macro_rules! make_table_column {
2-
($name: ident, $index: ident) => {
3-
/// Immutable view of a (non-ragged) column
4-
#[derive(Clone, Debug)]
5-
#[repr(transparent)]
6-
pub struct $name<'table, T>(&'table [T]);
1+
#[repr(transparent)]
2+
#[derive(Clone)]
3+
pub(crate) struct OpaqueTableColumn<'table, T>(pub(crate) &'table [T]);
74

8-
impl<'table, T> $name<'table, T> {
9-
pub(crate) fn new(column: &'table [T]) -> $name<'table, T> {
10-
Self(column)
11-
}
5+
impl<T> std::ops::Index<usize> for OpaqueTableColumn<'_, T> {
6+
type Output = T;
127

13-
/// View the underlying slice
14-
pub fn as_slice(&self) -> &[T] {
15-
self.0
16-
}
17-
18-
pub fn get_with_id(&self, index: crate::$index) -> Option<&T> {
19-
self.get_with_usize(usize::try_from(index).ok()?)
20-
}
21-
22-
pub fn get_with_size_type(&self, index: crate::SizeType) -> Option<&T> {
23-
self.get_with_usize(usize::try_from(index).ok()?)
24-
}
25-
26-
pub fn get_with_usize(&self, index: usize) -> Option<&T> {
27-
self.0.get(index)
28-
}
29-
}
30-
31-
impl<'table, T> $name<'table, T>
32-
where
33-
T: Copy,
34-
{
35-
pub fn iter(&self) -> impl Iterator<Item = T> + '_ {
36-
self.0.iter().map(|&value| value)
37-
}
38-
}
39-
40-
impl<T> std::ops::Index<usize> for $name<'_, T> {
41-
type Output = T;
42-
fn index(&self, index: usize) -> &Self::Output {
43-
&self.0[index]
44-
}
45-
}
46-
47-
impl<T> std::ops::Index<crate::$index> for $name<'_, T> {
48-
type Output = T;
49-
fn index(&self, index: crate::$index) -> &Self::Output {
50-
&self.0[usize::try_from(index).unwrap()]
51-
}
52-
}
53-
54-
impl<T> std::ops::Index<crate::SizeType> for $name<'_, T> {
55-
type Output = T;
56-
fn index(&self, index: crate::SizeType) -> &Self::Output {
57-
&self.0[usize::try_from(index).unwrap()]
58-
}
59-
}
60-
61-
impl<T> std::convert::AsRef<[T]> for $name<'_, T> {
62-
fn as_ref(&self) -> &[T] {
63-
self.as_slice()
64-
}
65-
}
66-
};
8+
fn index(&self, index: usize) -> &Self::Output {
9+
&self.0[index]
10+
}
6711
}
6812

69-
make_table_column!(NodeTableColumn, NodeId);
70-
make_table_column!(EdgeTableColumn, EdgeId);
71-
make_table_column!(SiteTableColumn, SiteId);
72-
make_table_column!(MutationTableColumn, MutationId);
73-
make_table_column!(PopulationTableColumn, PopulationId);
74-
make_table_column!(IndividualTableColumn, IndividualId);
75-
make_table_column!(MigrationTableColumn, MigrationId);
76-
77-
#[cfg(test)]
78-
make_table_column!(TestTableColumn, NodeId);
79-
80-
#[test]
81-
fn test_table_column_get_usize() {
82-
let v = vec![1, 2, 3];
83-
let c = TestTableColumn::new(&v);
84-
assert_eq!(c.get_with_usize(1), Some(&2))
85-
}
13+
impl<T> std::ops::Index<crate::SizeType> for OpaqueTableColumn<'_, T> {
14+
type Output = T;
8615

87-
#[test]
88-
fn test_table_column_get_size_type() {
89-
let v = vec![1, 2, 3];
90-
let c = TestTableColumn(&v);
91-
assert_eq!(c.get_with_size_type(crate::SizeType::from(1)), Some(&2))
16+
fn index(&self, index: crate::SizeType) -> &Self::Output {
17+
&self.0[usize::try_from(index).unwrap()]
18+
}
9219
}
9320

94-
#[test]
95-
fn test_table_column_get_id() {
96-
let v = vec![1, 2, 3];
97-
let c = TestTableColumn::new(&v);
98-
assert_eq!(c.get_with_id(1.into()), Some(&2))
21+
impl<T> std::ops::Index<crate::EdgeId> for OpaqueTableColumn<'_, T> {
22+
type Output = T;
23+
fn index(&self, index: crate::EdgeId) -> &Self::Output {
24+
&self.0[usize::try_from(index).unwrap()]
25+
}
9926
}
10027

101-
#[test]
102-
fn test_table_column_as_ref() {
103-
let v = vec![1, 2, 3];
104-
let c = TestTableColumn::new(&v);
105-
assert_eq!(c.as_ref(), v.as_slice())
28+
pub trait TableColumn<I, T>:
29+
std::ops::Index<I, Output = T>
30+
+ std::ops::Index<usize, Output = T>
31+
+ std::ops::Index<crate::SizeType, Output = T>
32+
{
33+
fn as_slice(&self) -> &[T];
10634
}
10735

108-
#[test]
109-
fn test_table_column_iter() {
110-
let v = vec![1, 2, 3];
111-
let c = TestTableColumn::new(&v);
112-
assert_eq!(c.iter().collect::<Vec::<_>>(), [1, 2, 3]);
36+
impl TableColumn<crate::EdgeId, crate::NodeId> for OpaqueTableColumn<'_, crate::NodeId> {
37+
fn as_slice(&self) -> &[crate::NodeId] {
38+
self.0
39+
}
11340
}
41+
// macro_rules! make_table_column {
42+
// ($name: ident, $index: ident) => {
43+
// /// Immutable view of a (non-ragged) column
44+
// #[derive(Clone, Debug)]
45+
// #[repr(transparent)]
46+
// pub struct $name<'table, T>(&'table [T]);
47+
//
48+
// impl<'table, T> $name<'table, T> {
49+
// pub(crate) fn new(column: &'table [T]) -> $name<'table, T> {
50+
// Self(column)
51+
// }
52+
//
53+
// /// View the underlying slice
54+
// pub fn as_slice(&self) -> &[T] {
55+
// self.0
56+
// }
57+
//
58+
// pub fn get_with_id(&self, index: crate::$index) -> Option<&T> {
59+
// self.get_with_usize(usize::try_from(index).ok()?)
60+
// }
61+
//
62+
// pub fn get_with_size_type(&self, index: crate::SizeType) -> Option<&T> {
63+
// self.get_with_usize(usize::try_from(index).ok()?)
64+
// }
65+
//
66+
// pub fn get_with_usize(&self, index: usize) -> Option<&T> {
67+
// self.0.get(index)
68+
// }
69+
// }
70+
//
71+
// impl<'table, T> $name<'table, T>
72+
// where
73+
// T: Copy,
74+
// {
75+
// pub fn iter(&self) -> impl Iterator<Item = T> + '_ {
76+
// self.0.iter().map(|&value| value)
77+
// }
78+
// }
79+
//
80+
// impl<T> std::ops::Index<usize> for $name<'_, T> {
81+
// type Output = T;
82+
// fn index(&self, index: usize) -> &Self::Output {
83+
// &self.0[index]
84+
// }
85+
// }
86+
//
87+
// impl<T> std::ops::Index<crate::$index> for $name<'_, T> {
88+
// type Output = T;
89+
// fn index(&self, index: crate::$index) -> &Self::Output {
90+
// &self.0[usize::try_from(index).unwrap()]
91+
// }
92+
// }
93+
//
94+
// impl<T> std::ops::Index<crate::SizeType> for $name<'_, T> {
95+
// type Output = T;
96+
// fn index(&self, index: crate::SizeType) -> &Self::Output {
97+
// &self.0[usize::try_from(index).unwrap()]
98+
// }
99+
// }
100+
//
101+
// impl<T> std::convert::AsRef<[T]> for $name<'_, T> {
102+
// fn as_ref(&self) -> &[T] {
103+
// self.as_slice()
104+
// }
105+
// }
106+
// };
107+
// }
108+
//
109+
// make_table_column!(NodeTableColumn, NodeId);
110+
// make_table_column!(EdgeTableColumn, EdgeId);
111+
// make_table_column!(SiteTableColumn, SiteId);
112+
// make_table_column!(MutationTableColumn, MutationId);
113+
// make_table_column!(PopulationTableColumn, PopulationId);
114+
// make_table_column!(IndividualTableColumn, IndividualId);
115+
// make_table_column!(MigrationTableColumn, MigrationId);
116+
//
117+
// #[cfg(test)]
118+
// make_table_column!(TestTableColumn, NodeId);
119+
//
120+
// #[test]
121+
// fn test_table_column_get_usize() {
122+
// let v = vec![1, 2, 3];
123+
// let c = TestTableColumn::new(&v);
124+
// assert_eq!(c.get_with_usize(1), Some(&2))
125+
// }
126+
//
127+
// #[test]
128+
// fn test_table_column_get_size_type() {
129+
// let v = vec![1, 2, 3];
130+
// let c = TestTableColumn(&v);
131+
// assert_eq!(c.get_with_size_type(crate::SizeType::from(1)), Some(&2))
132+
// }
133+
//
134+
// #[test]
135+
// fn test_table_column_get_id() {
136+
// let v = vec![1, 2, 3];
137+
// let c = TestTableColumn::new(&v);
138+
// assert_eq!(c.get_with_id(1.into()), Some(&2))
139+
// }
140+
//
141+
// #[test]
142+
// fn test_table_column_as_ref() {
143+
// let v = vec![1, 2, 3];
144+
// let c = TestTableColumn::new(&v);
145+
// assert_eq!(c.as_ref(), v.as_slice())
146+
// }
147+
//
148+
// #[test]
149+
// fn test_table_column_iter() {
150+
// let v = vec![1, 2, 3];
151+
// let c = TestTableColumn::new(&v);
152+
// assert_eq!(c.iter().collect::<Vec::<_>>(), [1, 2, 3]);
153+
// }

0 commit comments

Comments
 (0)