rendarray 0.2.0-alpha

An N-dimensional array for elements of arbitrary type. Lightweight array views and slicing. The Array is copy-on-write and similar to numpy’s ndarray.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use serde::ser::impls::SeqIteratorVisitor;
use serde::{self, Serialize, Deserialize};

use super::{
    Array,
    Dimension,
    Ix,
    Elements,
};

struct AVisitor<'a, A: 'a, D: 'a> {
    arr: &'a Array<A, D>,
    state: u32,
}

impl<A: Serialize, D: Serialize> Serialize for Array<A, D> where
    D: Dimension,
{
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where
        S: serde::Serializer
    {
        serializer.visit_named_map("Array", AVisitor {
            arr: self,
            state: 0,
        })
    }
}

impl<'a, A: Serialize, D: Serialize> Serialize for Elements<'a, A, D> where
    D: Dimension,
{
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where
        S: serde::Serializer
    {
        serializer.visit_seq(SeqIteratorVisitor::new(self.clone(), None))
    }
}

impl<'a, A, D> serde::ser::MapVisitor for AVisitor<'a, A, D> where
    A: Serialize,
    D: Serialize + Dimension,
{
    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
        where S: serde::Serializer
    {
        match self.state {
            0 => {
                self.state += 1;
                Ok(Some(try!(serializer.visit_map_elt("shape", self.arr.dim()))))
            }
            1 => {
                self.state += 1;
                Ok(Some(try!(serializer.visit_map_elt("data", self.arr.iter()))))
            }
            _ => Ok(None),
        }

    }
}