Thanks to visit codestin.com
Credit goes to docs.rs

arrayfire/core/
seq.rs

1use num::{One, Zero};
2
3#[cfg(feature = "afserde")]
4use serde::{Deserialize, Serialize};
5use std::default::Default;
6use std::fmt;
7
8use super::util::IndexableType;
9
10/// Sequences are used for indexing Arrays
11#[derive(Copy, Clone, Debug, PartialEq)]
12#[cfg_attr(feature = "afserde", derive(Serialize, Deserialize))]
13#[repr(C)]
14pub struct Seq<T: IndexableType> {
15    begin: T,
16    end: T,
17    step: T,
18}
19
20/// Default `Seq` spans all the elements along a dimension
21impl<T> Default for Seq<T>
22where
23    T: One + Zero + IndexableType,
24{
25    fn default() -> Self {
26        Self {
27            begin: One::one(),
28            end: One::one(),
29            step: Zero::zero(),
30        }
31    }
32}
33
34/// Enables use of `Seq` with `{}` format in print statements
35impl<T> fmt::Display for Seq<T>
36where
37    T: fmt::Display + IndexableType,
38{
39    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
40        write!(
41            f,
42            "[begin: {}, end: {}, step: {}]",
43            self.begin, self.end, self.step
44        )
45    }
46}
47
48impl<T> Seq<T>
49where
50    T: Copy + IndexableType,
51{
52    /// Create a `Seq` that goes from `begin` to `end` at a step size of `step`
53    pub fn new(begin: T, end: T, step: T) -> Self {
54        Self { begin, end, step }
55    }
56
57    /// Get begin index of Seq
58    pub fn begin(&self) -> T {
59        self.begin
60    }
61
62    /// Get end index of Seq
63    pub fn end(&self) -> T {
64        self.end
65    }
66
67    /// Get step size of Seq
68    pub fn step(&self) -> T {
69        self.step
70    }
71}
72
73#[cfg(test)]
74mod tests {
75    #[cfg(feature = "afserde")]
76    #[test]
77    fn seq_serde() {
78        use super::Seq;
79        use crate::seq;
80
81        let original = seq!(1:2:1);
82        let serd = match serde_json::to_string(&original) {
83            Ok(serialized_str) => serialized_str,
84            Err(e) => e.to_string(),
85        };
86
87        let deserd: Seq<i32> = serde_json::from_str(&serd).unwrap();
88        assert_eq!(deserd, original);
89    }
90}