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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

// Copyright 2020 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::io::{Decode, DecodeError, Encode, PathItem};
use crate::visit::{Visit, VisitError};
pub(crate) use wasmbin_derive::WasmbinCountable;

/// A trait for types that should be count-prefixed when encoded as a list.
pub(crate) trait WasmbinCountable {}

impl<T: WasmbinCountable + Encode> Encode for [T] {
    fn encode(&self, w: &mut impl std::io::Write) -> std::io::Result<()> {
        self.len().encode(w)?;
        for item in self {
            item.encode(w)?;
        }
        Ok(())
    }
}

impl<T> Encode for Vec<T>
where
    [T]: Encode,
{
    fn encode(&self, w: &mut impl std::io::Write) -> std::io::Result<()> {
        self.as_slice().encode(w)
    }
}

impl<T: WasmbinCountable + Decode> Decode for Vec<T> {
    fn decode(r: &mut impl std::io::Read) -> Result<Self, DecodeError> {
        let count = usize::decode(r)?;
        (0..count)
            .map(|i| T::decode(r).map_err(move |err| err.in_path(PathItem::Index(i))))
            .collect()
    }
}

macro_rules! impl_visit_for_iter {
    () => {
        fn visit_children<'a, VisitT: 'static, E, F: FnMut(&'a VisitT) -> Result<(), E>>(
            &'a self,
            f: &mut F,
        ) -> Result<(), VisitError<E>> {
            for (i, v) in self.iter().enumerate() {
                v.visit_child(f)
                    .map_err(move |err| err.in_path(PathItem::Index(i)))?;
            }
            Ok(())
        }

        fn visit_children_mut<VisitT: 'static, E, F: FnMut(&mut VisitT) -> Result<(), E>>(
            &mut self,
            f: &mut F,
        ) -> Result<(), VisitError<E>> {
            for (i, v) in self.iter_mut().enumerate() {
                v.visit_child_mut(f)
                    .map_err(move |err| err.in_path(PathItem::Index(i)))?;
            }
            Ok(())
        }
    };
}

impl<T: Visit> Visit for Vec<T> {
    impl_visit_for_iter!();
}

impl<T: Visit, const N: usize> Visit for [T; N] {
    impl_visit_for_iter!();
}

impl<T: Visit> Visit for Option<T> {
    fn visit_children<'a, VisitT: 'static, E, F: FnMut(&'a VisitT) -> Result<(), E>>(
        &'a self,
        f: &mut F,
    ) -> Result<(), VisitError<E>> {
        if let Some(v) = self {
            v.visit_child(f)?;
        }
        Ok(())
    }

    fn visit_children_mut<VisitT: 'static, E, F: FnMut(&mut VisitT) -> Result<(), E>>(
        &mut self,
        f: &mut F,
    ) -> Result<(), VisitError<E>> {
        if let Some(v) = self {
            v.visit_child_mut(f)?;
        }
        Ok(())
    }
}