Grcov report - param.rs

1

use crate::error::AetoliaResult;

2

use crate::model::param::{

3

    AlternateRepresentationParam, CalendarUserTypeParam, CommonNameParam, DelegatedFromParam,

4

    DelegatedToParam, DirectoryEntryReferenceParam, EncodingParam, FormatTypeParam,

5

    FreeBusyTimeTypeParam, LanguageParam, MembersParam, ParticipationStatusParam, RangeParam,

6

    RelationshipTypeParam, RoleParam, RsvpParam, SentByParam, TimeZoneIdParam,

7

    TriggerRelationshipParam, ValueTypeParam,

8

};

9

use crate::serialize::WriteModel;

10

use std::io::Write;

11

12

impl WriteModel for crate::model::param::Param {

13

836

    fn write_model<W: Write>(&self, writer: &mut W) -> AetoliaResult<()> {

14

        use crate::model::param::Param;

15

16

836

        match self {

17

40

            Param::AltRep(AlternateRepresentationParam { uri }) => {

18

40

                write!(writer, "ALTREP=\"{}\"", uri)?;

19

20

14

            Param::CommonName(CommonNameParam { name }) => {

21

14

                write!(writer, "CN={}", name)?;

22

23

18

            Param::ValueType(ValueTypeParam { value }) => {

24

18

                write!(writer, "VALUE=")?;

25

18

                value.write_model(writer)?;

26

27

30

            Param::TimeZoneId(TimeZoneIdParam { tz_id, unique }) => {

28

30

                writer.write_all(b"TZID=")?;

29

30

                if *unique {

30

                    writer.write_all(b"/")?;

31

32

30

                writer.write_all(tz_id.as_bytes())?;

33

34

70

            Param::Language(LanguageParam { language }) => {

35

70

                writer.write_all(b"LANGUAGE=")?;

36

70

                language.write_model(writer)?;

37

38

14

            Param::DirectoryEntryReference(DirectoryEntryReferenceParam { uri }) => {

39

14

                write!(writer, "DIR=\"{}\"", uri)?;

40

41

14

            Param::SentBy(SentByParam { address }) => {

42

14

                write!(writer, "SENT-BY=\"{}\"", address)?;

43

44

6

            Param::Range(RangeParam { range }) => {

45

6

                write!(writer, "RANGE=")?;

46

6

                range.write_model(writer)?;

47

48

            Param::FormatType(FormatTypeParam {

49

10

                type_name,

50

10

                sub_type_name,

51

10

            }) => {

52

10

                write!(writer, "FMTTYPE={}/{}", type_name, sub_type_name)?;

53

54

2

            Param::Encoding(EncodingParam { encoding }) => {

55

2

                writer.write_all(b"ENCODING=")?;

56

2

                encoding.write_model(writer)?;

57

58

6

            Param::CalendarUserType(CalendarUserTypeParam { cu_type }) => {

59

6

                writer.write_all(b"CUTYPE=")?;

60

6

                cu_type.write_model(writer)?;

61

62

6

            Param::Members(MembersParam { members }) => {

63

6

                writer.write_all(b"MEMBER=")?;

64

6

                if let Some(member) = members.first() {

65

6

                    write!(writer, "\"{}\"", member)?;

66

67

6

                for member in members.iter().skip(1) {

68

                    write!(writer, ",\"{}\"", member)?;

69

70

71

6

            Param::Role(RoleParam { role }) => {

72

6

                writer.write_all(b"ROLE=")?;

73

6

                role.write_model(writer)?;

74

75

6

            Param::ParticipationStatus(ParticipationStatusParam { status }) => {

76

6

                writer.write_all(b"PARTSTAT=")?;

77

6

                status.write_model(writer)?;

78

79

6

            Param::Rsvp(RsvpParam { rsvp }) => {

80

6

                writer.write_all(b"RSVP=")?;

81

6

                rsvp.write_model(writer)?;

82

83

6

            Param::DelegatedTo(DelegatedToParam { delegates }) => {

84

6

                writer.write_all(b"DELEGATED-TO=")?;

85

6

                if let Some(delegate) = delegates.first() {

86

6

                    write!(writer, "\"{}\"", delegate)?;

87

88

6

                for delegate in delegates.iter().skip(1) {

89

                    write!(writer, ",\"{}\"", delegate)?;

90

91

92

6

            Param::DelegatedFrom(DelegatedFromParam { delegators }) => {

93

6

                writer.write_all(b"DELEGATED-FROM=")?;

94

6

                if let Some(delegate) = delegators.first() {

95

6

                    write!(writer, "\"{}\"", delegate)?;

96

97

6

                for delegate in delegators.iter().skip(1) {

98

                    write!(writer, ",\"{}\"", delegate)?;

99

100

101

6

            Param::RelationshipType(RelationshipTypeParam { relationship }) => {

102

6

                writer.write_all(b"RELTYPE=")?;

103

6

                relationship.write_model(writer)?;

104

105

2

            Param::FreeBusyTimeType(FreeBusyTimeTypeParam { fb_type }) => {

106

2

                writer.write_all(b"FBTYPE=")?;

107

2

                fb_type.write_model(writer)?;

108

109

            Param::TriggerRelationship(TriggerRelationshipParam {

110

4

                trigger_relationship: related,

111

4

            }) => {

112

4

                writer.write_all(b"RELATED=")?;

113

4

                related.write_model(writer)?;

114

115

564

            Param::Other { name, value } => {

116

564

                write!(writer, "{}={}", name, value)?;

117

118

            Param::Others { name, values } => {

119

                write!(writer, "{}=", name)?;

120

                if let Some(value) = values.first() {

121

                    write!(writer, "\"{}\"", value)?;

122

123

                for value in values.iter().skip(1) {

124

                    write!(writer, ",\"{}\"", value)?;

125

126

127

128

129

836

        Ok(())

130

836

131