lcov_parser/
macros.rs

1// Copyright (c) 2015-2016 lcov-parser developers
2//
3// Licensed under the Apache License, Version 2.0
4// <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT
5// license <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6// option. All files in the project carrying such notice may not be copied,
7// modified, or distributed except according to those terms.
8
9#[macro_export]
10macro_rules! impl_summary {
11    ($dest:ty, $field:ident<$key:ty, $value:ty>) => {
12        impl $crate::report::summary::Summary<$key, $value> for $dest {
13            fn iter(&self) -> ::std::collections::btree_map::Iter<$key, $value> {
14                self.$field.iter()
15            }
16            fn contains_key(&self, key: &$key) -> bool {
17                self.$field.contains_key(key)
18            }
19            fn get(&self, key: &$key) -> Option<&$value> {
20                self.$field.get(key)
21            }
22            fn len(&self) -> usize {
23                self.$field.len()
24            }
25        }
26    }
27}
28
29#[macro_export]
30macro_rules! impl_try_merge_self_summary {
31    ($dest:ty:$field:ident, $err:ty) => {
32        impl<'a> $crate::merger::ops::TryMerge<&'a $dest> for $dest {
33            type Err = $err;
34
35            fn try_merge(&mut self, other: &'a $dest) -> MergeResult<Self::Err> {
36                for (key, other_value) in other.iter() {
37                    if !self.$field.contains_key(key) {
38                        self.$field.insert(key.clone(), other_value.clone());
39                        continue;
40                    }
41                    let value = self.$field.get_mut(key).unwrap();
42                    let _ = value.try_merge(other_value)?;
43                }
44                Ok(())
45            }
46        }
47    }
48}
49
50#[macro_export]
51macro_rules! impl_try_merge {
52    ($dest:ty:$field:ident, $append:ty, $err:ty) => {
53        impl<'a> $crate::merger::ops::TryMerge<&'a $append> for $dest {
54            type Err = $err;
55
56            fn try_merge(&mut self, data: &'a $append) -> MergeResult<Self::Err> {
57                self.$field.try_merge(data)
58            }
59        }
60    };
61}
62
63#[macro_export]
64macro_rules! impl_from_error {
65    ($from:ty, $dest:ident::$item:ident) => {
66        impl ::std::convert::From<$from> for $dest {
67            fn from(error: $from) -> Self {
68                $dest::$item(error)
69            }
70        }
71    };
72    ($from:ty, $nest_dest:ident::$nest_item:ident=>$dest:ident::$item:ident) => {
73        impl From<$from> for MergeError {
74            fn from(error: $from) -> Self {
75                $dest::$item($nest_dest::$nest_item(error))
76            }
77        }
78    }
79}