Struct Dataset

pub struct Dataset<S: Schema> { /* private fields */ }

A dataset in flat. The same dataset may be observed through multiple views.

// Note, explicit type annotation included for clarity.
// We encourage consumers to allow the compiler to infer the type implicitly.
let builder: Dataset<Schema1<f64>> = DatasetBuilder::new(Schemas::one("dim1")).build();

Implementations

impl Dataset<Schema1<f64>>

pub fn reflect_1st(&self) -> View1Full<'_, Schema1<f64>>

Take a reflective view of this 1-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (1st), and use all other dimensions in the frame of the widget. The term ‘reflection’ refers to the fact that the value will appear in both in the frame and rendering of the widget.

r#"
Frame..   | Rendering....
(dim1, )  | aggregate(dim1)"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema1<T> where T = {f64, .., u8}.
• pointer_impls: implemented for Schema1<Dt> where T: Clone + Into<f64>, Dt: Deref<Target = T>.

impl<T> Dataset<Schema2<T, f64>>

pub fn reflect_2nd(&self) -> View2Full<'_, Schema2<T, f64>>

Take a reflective view of this 2-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (2nd), and use all other dimensions in the frame of the widget. The term ‘reflection’ refers to the fact that the value will appear in both in the frame and rendering of the widget.

r#"
Frame..       | Rendering..
(dim1, dim2)  | aggregate(dim2)"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema2<_, U> where U = {f64, .., u8}.
• pointer_impls: implemented for Schema2<_, Du> where U: Clone + Into<f64>, Du: Deref<Target = U>.

pub fn view_2nd(&self) -> View2Regular<'_, Schema2<T, f64>>

Take a regular view of this 2-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (2nd), and use all other dimensions in the frame of the widget.

r#"
Frame..   | Rendering..
(dim1, )  | aggregate(dim2)"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema2<_, U> where U = {f64, .., u8}.
• pointer_impls: implemented for Schema2<_, Du> where U: Clone + Into<f64>, Du: Deref<Target = U>.

pub fn breakdown_2nd(&self) -> View2Breakdown2nd<'_, Schema2<T, f64>>

Take a breakdown view of this 2-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the breakdown of the final dimension (2nd), and use all other dimensions in the frame of the widget.

r#"
Frame..   | Breakdown Rendering..              |
(dim1, )  | breakdown(dim2, aggregate(dim2)).. |"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema2<_, U> where U = {f64, .., u8}.
• pointer_impls: implemented for Schema2<_, Du> where U: Clone + Into<f64>, Du: Deref<Target = U>.

impl<T, U> Dataset<Schema3<T, U, f64>>

pub fn reflect_3rd(&self) -> View3Full<'_, Schema3<T, U, f64>>

Take a reflective view of this 3-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (3rd), and use all other dimensions in the frame of the widget. The term ‘reflection’ refers to the fact that the value will appear in both in the frame and rendering of the widget.

r#"
Frame..             | Rendering..
(dim1, dim2, dim3)  | aggregate(dim3)"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema3<_, _, V> where V = {f64, .., u8}.
• pointer_impls: implemented for Schema3<_, _, Dv> where V: Clone + Into<f64>, Dv: Deref<Target = V>.

pub fn view_3rd(&self) -> View3Regular<'_, Schema3<T, U, f64>>

Take a regular view of this 3-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (3rd), and use all other dimensions in the frame of the widget.

r#"
Frame..       | Rendering..
(dim1, dim2)  | aggregate(dim3)"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema3<_, _, V> where V = {f64, .., u8}.
• pointer_impls: implemented for Schema3<_, _, Dv> where V: Clone + Into<f64>, Dv: Deref<Target = V>.

pub fn breakdown_3rd(&self) -> View3Breakdown3rd<'_, Schema3<T, U, f64>>

Take a breakdown view of this 3-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the breakdown of the final dimension (3rd), and use all other dimensions in the frame of the widget.

r#"
Frame..       | Breakdown Rendering..              |
(dim1, dim2)  | breakdown(dim3, aggregate(dim3)).. |"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema3<_, _, V> where V = {f64, .., u8}.
• pointer_impls: implemented for Schema3<_, _, Dv> where V: Clone + Into<f64>, Dv: Deref<Target = V>.

pub fn view_3rd_breakdown_2nd( &self, ) -> View3Breakdown2ndView3rd<'_, Schema3<T, U, f64>>

Take a view+breakdown view of this 3-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (3rd) under a breakdown of the next dimension (2nd), and use all other dimensions in the frame of the widget.

r#"
Frame..   | Breakdown Rendering..              |
(dim1, )  | breakdown(dim2, aggregate(dim3)).. |"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema3<_, _, V> where V = {f64, .., u8}.
• pointer_impls: implemented for Schema3<_, _, Dv> where V: Clone + Into<f64>, Dv: Deref<Target = V>.

impl<T, U, V> Dataset<Schema4<T, U, V, f64>>

pub fn reflect_4th(&self) -> View4Full<'_, Schema4<T, U, V, f64>>

Take a reflective view of this 4-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (4th), and use all other dimensions in the frame of the widget. The term ‘reflection’ refers to the fact that the value will appear in both in the frame and rendering of the widget.

r#"
Frame..                   | Rendering..
(dim1, dim2, dim3, dim4)  | aggregate(dim4)"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema4<_, _, _, W> where W = {f64, .., u8}.
• pointer_impls: implemented for Schema4<_, _, _, Dw> where W: Clone + Into<f64>, Dw: Deref<Target = W>.

pub fn view_4th(&self) -> View4Regular<'_, Schema4<T, U, V, f64>>

Take a regular view of this 4-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (4th), and use all other dimensions in the frame of the widget.

r#"
Frame..             | Rendering..
(dim1, dim2, dim3)  | aggregate(dim4)"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema4<_, _, _, W> where W = {f64, .., u8}.
• pointer_impls: implemented for Schema4<_, _, _, Dw> where W: Clone + Into<f64>, Dw: Deref<Target = W>.

pub fn breakdown_4th(&self) -> View4Breakdown4th<'_, Schema4<T, U, V, f64>>

Take a breakdown view of this 4-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the breakdown of the final dimension (4th), and use all other dimensions in the frame of the widget.

r#"
Frame..             | Breakdown Rendering..              |
(dim1, dim2, dim3)  | breakdown(dim4, aggregate(dim4)).. |"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema4<_, _, _, W> where W = {f64, .., u8}.
• pointer_impls: implemented for Schema4<_, _, _, Dw> where W: Clone + Into<f64>, Dw: Deref<Target = W>.

pub fn view_4th_breakdown_3rd( &self, ) -> View4Breakdown3rdView4th<'_, Schema4<T, U, V, f64>>

Take a view+breakdown of this 4-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the final dimension (4th) under a breakdown of the next dimension (3rd), and use all other dimensions in the frame of the widget.

r#"
Frame..       | Breakdown Rendering..              |
(dim1, dim2)  | breakdown(dim3, aggregate(dim4)).. |"#

Requires feature primitive_impls or pointer_impls.

• primitive_impls: implemented for Schema4<_, _, _, W> where W = {f64, .., u8}.
• pointer_impls: implemented for Schema4<_, _, _, Dw> where W: Clone + Into<f64>, Dw: Deref<Target = W>.

impl<T> Dataset<Schema1<T>>

pub fn count(&self) -> View1Full<'_, Schema1<T>>

Take a counting view of this N-dimensional dataset. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the occurrences of each dimensional vector, while using all dimensions in the frame of the widget.

r#"
Frame..  | Rendering..
(*,)     | aggregate(count())"#

Implemented for Schema1<_>, Schema2<_, _>, Schema3<_, _, _>.

impl<T, U> Dataset<Schema2<T, U>>

pub fn count_breakdown_2nd(&self) -> View2Breakdown2ndCount<'_, Schema2<T, U>>

Take a view of this 2-dimensional dataset breaking down the 2nd column. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the breakdown of the final dimension (2nd), and use all other dimensions in the frame of the widget. Rather than displaying the value of the final dimension, the occurrences of each dimensional vector are counted.

r#"
Frame..   | Breakdown Rendering..                 |
(dim1, )  | breakdown(dim2, aggregate(count())).. |"#

Implemented for Schema2<_, _>.

impl<T, U, V> Dataset<Schema3<T, U, V>>

pub fn count_breakdown_3rd( &self, ) -> View3Breakdown3rdCount<'_, Schema3<T, U, V>>

Take a view of this 3-dimensional dataset breaking down the 3rd column. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the breakdown of the final dimension (3rd), and use all other dimensions in the frame of the widget.

r#"
Frame..       | Breakdown Rendering..                 |
(dim1, dim2)  | breakdown(dim3, aggregate(count())).. |"#

Implemented for Schema3<_, _, _>.

impl<T, U, V, W> Dataset<Schema4<T, U, V, W>>

pub fn count_breakdown_4th( &self, ) -> View4Breakdown4thCount<'_, Schema4<T, U, V, W>>

Take a view of this 4-dimensional dataset breaking down the 4th column. Views are rendered differently by different widgets, but always have a frame on the left and a rendering on the right.

This view will render the breakdown of the final dimension (4th), and use all other dimensions in the frame of the widget.

r#"
Frame..             | Breakdown Rendering..                 |
(dim1, dim2, dim3)  | breakdown(dim4, aggregate(count())).. |"#

Implemented for Schema4<_, _, _, _>.