Struct tskit::OwningNodeTable
source · pub struct OwningNodeTable { /* private fields */ }
Expand description
A standalone node table that owns its data.
Examples
use tskit::OwningNodeTable;
let mut nodes = OwningNodeTable::default();
let rowid = nodes.add_row(0, 1.1, -1, -1).unwrap();
assert_eq!(rowid, 0);
assert_eq!(nodes.num_rows(), 1);
An example with metadata.
This requires the cargo feature "derive"
for tskit
.
use tskit::OwningNodeTable;
#[derive(serde::Serialize,
serde::Deserialize,
tskit::metadata::NodeMetadata)]
#[serializer("serde_json")]
struct NodeMetadata {
value: i32,
}
let metadata = NodeMetadata{value: 42};
let mut nodes = OwningNodeTable::default();
let rowid = nodes.add_row_with_metadata(0, 1., -1, -1, &metadata).unwrap();
assert_eq!(rowid, 0);
match nodes.metadata::<NodeMetadata>(rowid) {
// rowid is in range, decoding succeeded
Some(Ok(decoded)) => assert_eq!(decoded.value, 42),
// rowid is in range, decoding failed
Some(Err(e)) => panic!("error decoding metadata: {:?}", e),
None => panic!("row id out of range")
}
Implementations§
source§impl OwningNodeTable
impl OwningNodeTable
sourcepub fn clear(&mut self) -> TskReturnValue
pub fn clear(&mut self) -> TskReturnValue
Clear the table.
source§impl OwningNodeTable
impl OwningNodeTable
pub fn as_ptr(&self) -> *const tsk_node_table_t
pub fn as_mut_ptr(&mut self) -> *mut tsk_node_table_t
source§impl OwningNodeTable
impl OwningNodeTable
pub fn add_row<F, T, P, I>( &mut self, flags: F, time: T, population: P, individual: I ) -> Result<NodeId, TskitError>where F: Into<NodeFlags>, T: Into<Time>, P: Into<PopulationId>, I: Into<IndividualId>,
pub fn add_row_with_metadata<F, T, P, I, N>( &mut self, flags: F, time: T, population: P, individual: I, metadata: &N ) -> Result<NodeId, TskitError>where F: Into<NodeFlags>, T: Into<Time>, P: Into<PopulationId>, I: Into<IndividualId>, N: NodeMetadata,
sourcepub fn add_row_with_defaults<T: Into<Time> + Copy, D: DefaultNodeData>(
&mut self,
time: T,
defaults: &D
) -> Result<NodeId, TskitError>
pub fn add_row_with_defaults<T: Into<Time> + Copy, D: DefaultNodeData>( &mut self, time: T, defaults: &D ) -> Result<NodeId, TskitError>
Add row with defaults
Examples
let node_defaults = tskit::NodeDefaults::default();
let rv = nodes.add_row_with_defaults(1.0, &node_defaults).unwrap();
assert_eq!(rv, 0);
let rv = nodes.add_row_with_defaults(1.0, &node_defaults).unwrap();
assert_eq!(rv, 1);
Methods from Deref<Target = NodeTable>§
pub fn flags_array_mut(&mut self) -> &mut [NodeFlags]
pub fn time_array_mut(&mut self) -> &mut [Time]
sourcepub fn population<N: Into<NodeId> + Copy>(&self, row: N) -> Option<PopulationId>
pub fn population<N: Into<NodeId> + Copy>(&self, row: N) -> Option<PopulationId>
sourcepub fn deme<N: Into<NodeId> + Copy>(&self, row: N) -> Option<PopulationId>
pub fn deme<N: Into<NodeId> + Copy>(&self, row: N) -> Option<PopulationId>
Return the population
value from row row
of the table.
Examples
See NodeTable::population
for examples.
Returns
Some(population)
ifrow
is valid.None
otherwise.
sourcepub fn individual<N: Into<NodeId> + Copy>(&self, row: N) -> Option<IndividualId>
pub fn individual<N: Into<NodeId> + Copy>(&self, row: N) -> Option<IndividualId>
sourcepub fn metadata<T: NodeMetadata>(
&self,
row: NodeId
) -> Option<Result<T, TskitError>>
pub fn metadata<T: NodeMetadata>( &self, row: NodeId ) -> Option<Result<T, TskitError>>
Retrieve decoded metadata for a row
.
Returns
Some(Ok(T))
ifrow
is valid and decoding succeeded.Some(Err(_))
ifrow
is not valid and decoding failed.None
ifrow
is not valid.
Errors
TskitError::MetadataError
if decoding fails.
Examples.
The big-picture semantics are the same for all table types.
See crate::IndividualTable::metadata
for examples.
sourcepub fn iter(&self) -> impl Iterator<Item = NodeTableRow> + '_
pub fn iter(&self) -> impl Iterator<Item = NodeTableRow> + '_
Return an iterator over rows of the table.
The value of the iterator is NodeTableRow
.
pub fn lending_iter(&self) -> NodeTableRowView<'_>
sourcepub fn row_view<N: Into<NodeId> + Copy>(
&self,
r: N
) -> Option<NodeTableRowView<'_>>
pub fn row_view<N: Into<NodeId> + Copy>( &self, r: N ) -> Option<NodeTableRowView<'_>>
Return a view of row r
of the table.
Parameters
r
: the row id.
Returns
Some(row view)
ifr
is validNone
otherwise
sourcepub fn samples_as_vector(&self) -> Vec<NodeId>
pub fn samples_as_vector(&self) -> Vec<NodeId>
Obtain a vector containing the indexes (“ids”)
of all nodes for which crate::TSK_NODE_IS_SAMPLE
is true
.
sourcepub fn create_node_id_vector(
&self,
f: impl FnMut(&NodeTableRow) -> bool
) -> Vec<NodeId>
pub fn create_node_id_vector( &self, f: impl FnMut(&NodeTableRow) -> bool ) -> Vec<NodeId>
Obtain a vector containing the indexes (“ids”) of all nodes satisfying a certain criterion.
sourcepub fn time_slice(&self) -> &[Time]
pub fn time_slice(&self) -> &[Time]
Get the time column as a slice
sourcepub fn time_slice_raw(&self) -> &[f64]
pub fn time_slice_raw(&self) -> &[f64]
Get the time column as a slice
sourcepub fn time_slice_mut(&mut self) -> &mut [Time]
pub fn time_slice_mut(&mut self) -> &mut [Time]
Get the time column as a mutable slice
Examples
For a crate::TableCollection
, accessing the table creates a temporary
that will be dropped, causing this code to not compile:
let time = tables.nodes().time_slice_mut();
println!("{}", time.len()); // ERROR: the temporary node table is dropped by now
Treating the returned slice as an iterable succeeds:
for time in tables.nodes_mut().time_slice_mut() {
*time = 55.0.into(); // change each node's time value
}
assert!(tables.nodes_mut().time_slice_mut().iter().all(|t| t == &55.0));
Panics
Internally, we rely on a conversion of u64 to usize. This conversion is fallible on some platforms. If the conversion fails, this function will panic.
sourcepub fn time_slice_raw_mut(&mut self) -> &mut [f64]
pub fn time_slice_raw_mut(&mut self) -> &mut [f64]
Get the time column as a mutable slice
sourcepub fn flags_slice(&self) -> &[NodeFlags]
pub fn flags_slice(&self) -> &[NodeFlags]
Get the flags column as a slice
sourcepub fn flags_slice_raw(&self) -> &[tsk_flags_t]
pub fn flags_slice_raw(&self) -> &[tsk_flags_t]
Get the flags column as a slice
sourcepub fn flags_slice_mut(&mut self) -> &mut [NodeFlags]
pub fn flags_slice_mut(&mut self) -> &mut [NodeFlags]
Get the flags column as a mutable slice
Examples
let flags = tables.nodes_mut().flags_slice_mut();
for flag in flags {
// Can do something...
}
for flag in tables.nodes_mut().flags_slice_mut() {
}
The returned slice is mutable, allowing one to do things like clear the sample status of all nodes:
A copy of the flags can be obtained by collecting results into Vec
:
for flag in tables.nodes_mut().flags_slice_mut() {
flag.remove(tskit::NodeFlags::IS_SAMPLE);
}
assert!(!tables.nodes_mut().flags_slice_mut().iter().any(|f| f.is_sample()));
assert!(tables.nodes().samples_as_vector().is_empty());
let flags = tables.nodes_mut().flags_slice_mut().to_vec();
Owning tables
The ownership semantics differ when tables are not part of a table collection:
let mut nodes = tskit::OwningNodeTable::default();
assert!(nodes.add_row(tskit::NodeFlags::IS_SAMPLE, 10., -1, -1).is_ok());
let flags = nodes.flags_slice_mut();
assert!(flags.iter().all(|f| f.is_sample()));
// while we are at it, let's use our node
// table to populate a table collection.
let mut tables = tskit::TableCollection::new(10.0).unwrap();
tables.set_nodes(&nodes);
assert_eq!(tables.nodes().num_rows(), 1);
assert_eq!(tables.nodes_mut().flags_slice_mut().iter().filter(|f| f.is_sample()).count(), 1);
Panics
Internally, we rely on a conversion of u64 to usize. This conversion is fallible on some platforms. If the conversion fails, this function will panic.
sourcepub fn flags_slice_raw_mut(&mut self) -> &mut [tsk_flags_t]
pub fn flags_slice_raw_mut(&mut self) -> &mut [tsk_flags_t]
Get the flags column as a mutable slice
sourcepub fn individual_slice(&self) -> &[IndividualId]
pub fn individual_slice(&self) -> &[IndividualId]
Get the individual column as a slice
sourcepub fn individual_slice_raw(&self) -> &[tsk_id_t]
pub fn individual_slice_raw(&self) -> &[tsk_id_t]
Get the individual column as a slice
sourcepub fn population_slice(&self) -> &[PopulationId]
pub fn population_slice(&self) -> &[PopulationId]
Get the population column as a slice
sourcepub fn population_slice_raw(&self) -> &[tsk_id_t]
pub fn population_slice_raw(&self) -> &[tsk_id_t]
Get the population column as a slice