From 60c817e1b0f3c3d6b52b08f2eadcd1b6df699604 Mon Sep 17 00:00:00 2001 From: Jonas Platte Date: Wed, 23 Oct 2019 02:09:34 +0200 Subject: [PATCH] Restore Rust 1.34.2 compatibility --- README.md | 2 +- ruma-events-macros/src/parse.rs | 6 +- src/collections/all.rs | 196 ++++++++++++++------------- src/collections/only.rs | 64 ++++----- src/collections/raw/all.rs | 226 ++++++++++++++++++++------------ src/collections/raw/only.rs | 66 ++++++---- src/key/verification/start.rs | 4 +- src/lib.rs | 4 +- src/room/encrypted.rs | 10 +- src/room/message.rs | 28 ++-- src/stripped.rs | 109 ++++++++------- 11 files changed, 412 insertions(+), 303 deletions(-) diff --git a/README.md b/README.md index 6b5f05d2..8bc8a9ef 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ ## Minimum Rust version -ruma-events requires Rust 1.34 or later. +ruma-events requires Rust 1.34.2 or later. ## Documentation diff --git a/ruma-events-macros/src/parse.rs b/ruma-events-macros/src/parse.rs index 22bec1c1..e2fb6ba5 100644 --- a/ruma-events-macros/src/parse.rs +++ b/ruma-events-macros/src/parse.rs @@ -215,20 +215,20 @@ impl Parse for RumaEventField { .into_iter() .collect(); - Ok(Self::InlineStruct(FieldInlineStruct { + Ok(RumaEventField::InlineStruct(FieldInlineStruct { attrs, member, colon_token, fields, })) } - "content_type_alias" => Ok(Self::Block(FieldBlock { + "content_type_alias" => Ok(RumaEventField::Block(FieldBlock { attrs: input.call(Attribute::parse_outer)?, member: input.parse()?, colon_token: input.parse()?, typedef: input.parse()?, })), - _ => Ok(Self::Value(input.parse()?)), + _ => Ok(RumaEventField::Value(input.parse()?)), } } } diff --git a/src/collections/all.rs b/src/collections/all.rs index 72687547..6482f42c 100644 --- a/src/collections/all.rs +++ b/src/collections/all.rs @@ -343,54 +343,60 @@ impl TryFromRaw for Event { use raw::Event::*; match raw { - CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c), - CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c), - CallHangup(c) => conv(CallHangup, Self::CallHangup, c), - CallInvite(c) => conv(CallInvite, Self::CallInvite, c), - Direct(c) => conv(Direct, Self::Direct, c), - Dummy(c) => conv(Dummy, Self::Dummy, c), - ForwardedRoomKey(c) => conv(ForwardedRoomKey, Self::ForwardedRoomKey, c), - FullyRead(c) => conv(FullyRead, Self::FullyRead, c), - IgnoredUserList(c) => conv(IgnoredUserList, Self::IgnoredUserList, c), - KeyVerificationAccept(c) => conv(KeyVerificationAccept, Self::KeyVerificationAccept, c), - KeyVerificationCancel(c) => conv(KeyVerificationCancel, Self::KeyVerificationCancel, c), - KeyVerificationKey(c) => conv(KeyVerificationKey, Self::KeyVerificationKey, c), - KeyVerificationMac(c) => conv(KeyVerificationMac, Self::KeyVerificationMac, c), - KeyVerificationRequest(c) => { - conv(KeyVerificationRequest, Self::KeyVerificationRequest, c) + CallAnswer(c) => conv(CallAnswer, Event::CallAnswer, c), + CallCandidates(c) => conv(CallCandidates, Event::CallCandidates, c), + CallHangup(c) => conv(CallHangup, Event::CallHangup, c), + CallInvite(c) => conv(CallInvite, Event::CallInvite, c), + Direct(c) => conv(Direct, Event::Direct, c), + Dummy(c) => conv(Dummy, Event::Dummy, c), + ForwardedRoomKey(c) => conv(ForwardedRoomKey, Event::ForwardedRoomKey, c), + FullyRead(c) => conv(FullyRead, Event::FullyRead, c), + IgnoredUserList(c) => conv(IgnoredUserList, Event::IgnoredUserList, c), + KeyVerificationAccept(c) => { + conv(KeyVerificationAccept, Event::KeyVerificationAccept, c) } - KeyVerificationStart(c) => conv(KeyVerificationStart, Self::KeyVerificationStart, c), - Presence(c) => conv(Presence, Self::Presence, c), - PushRules(c) => conv(PushRules, Self::PushRules, c), - Receipt(c) => conv(Receipt, Self::Receipt, c), - RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c), - RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c), - RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c), - RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c), - RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c), - RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c), - RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c), - RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c), - RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c), - RoomMember(c) => conv(RoomMember, Self::RoomMember, c), - RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c), - RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c), - RoomName(c) => conv(RoomName, Self::RoomName, c), - RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c), - RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c), - RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c), - RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c), - RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c), - RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c), - RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c), - RoomKey(c) => conv(RoomKey, Self::RoomKey, c), - RoomKeyRequest(c) => conv(RoomKeyRequest, Self::RoomKeyRequest, c), - Sticker(c) => conv(Sticker, Self::Sticker, c), - Tag(c) => conv(Tag, Self::Tag, c), - Typing(c) => conv(Typing, Self::Typing, c), - Custom(c) => Ok(Self::Custom(c)), - CustomRoom(c) => Ok(Self::CustomRoom(c)), - CustomState(c) => Ok(Self::CustomState(c)), + KeyVerificationCancel(c) => { + conv(KeyVerificationCancel, Event::KeyVerificationCancel, c) + } + KeyVerificationKey(c) => conv(KeyVerificationKey, Event::KeyVerificationKey, c), + KeyVerificationMac(c) => conv(KeyVerificationMac, Event::KeyVerificationMac, c), + KeyVerificationRequest(c) => { + conv(KeyVerificationRequest, Event::KeyVerificationRequest, c) + } + KeyVerificationStart(c) => conv(KeyVerificationStart, Event::KeyVerificationStart, c), + Presence(c) => conv(Presence, Event::Presence, c), + PushRules(c) => conv(PushRules, Event::PushRules, c), + Receipt(c) => conv(Receipt, Event::Receipt, c), + RoomAliases(c) => conv(RoomAliases, Event::RoomAliases, c), + RoomAvatar(c) => conv(RoomAvatar, Event::RoomAvatar, c), + RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Event::RoomCanonicalAlias, c), + RoomCreate(c) => conv(RoomCreate, Event::RoomCreate, c), + RoomEncrypted(c) => conv(RoomEncrypted, Event::RoomEncrypted, c), + RoomEncryption(c) => conv(RoomEncryption, Event::RoomEncryption, c), + RoomGuestAccess(c) => conv(RoomGuestAccess, Event::RoomGuestAccess, c), + RoomHistoryVisibility(c) => { + conv(RoomHistoryVisibility, Event::RoomHistoryVisibility, c) + } + RoomJoinRules(c) => conv(RoomJoinRules, Event::RoomJoinRules, c), + RoomMember(c) => conv(RoomMember, Event::RoomMember, c), + RoomMessage(c) => conv(RoomMessage, Event::RoomMessage, c), + RoomMessageFeedback(c) => conv(RoomMessageFeedback, Event::RoomMessageFeedback, c), + RoomName(c) => conv(RoomName, Event::RoomName, c), + RoomPinnedEvents(c) => conv(RoomPinnedEvents, Event::RoomPinnedEvents, c), + RoomPowerLevels(c) => conv(RoomPowerLevels, Event::RoomPowerLevels, c), + RoomRedaction(c) => conv(RoomRedaction, Event::RoomRedaction, c), + RoomServerAcl(c) => conv(RoomServerAcl, Event::RoomServerAcl, c), + RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Event::RoomThirdPartyInvite, c), + RoomTombstone(c) => conv(RoomTombstone, Event::RoomTombstone, c), + RoomTopic(c) => conv(RoomTopic, Event::RoomTopic, c), + RoomKey(c) => conv(RoomKey, Event::RoomKey, c), + RoomKeyRequest(c) => conv(RoomKeyRequest, Event::RoomKeyRequest, c), + Sticker(c) => conv(Sticker, Event::Sticker, c), + Tag(c) => conv(Tag, Event::Tag, c), + Typing(c) => conv(Typing, Event::Typing, c), + Custom(c) => Ok(Event::Custom(c)), + CustomRoom(c) => Ok(Event::CustomRoom(c)), + CustomState(c) => Ok(Event::CustomState(c)), } } } @@ -404,33 +410,37 @@ impl TryFromRaw for RoomEvent { use raw::RoomEvent::*; match raw { - CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c), - CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c), - CallHangup(c) => conv(CallHangup, Self::CallHangup, c), - CallInvite(c) => conv(CallInvite, Self::CallInvite, c), - RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c), - RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c), - RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c), - RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c), - RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c), - RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c), - RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c), - RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c), - RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c), - RoomMember(c) => conv(RoomMember, Self::RoomMember, c), - RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c), - RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c), - RoomName(c) => conv(RoomName, Self::RoomName, c), - RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c), - RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c), - RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c), - RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c), - RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c), - RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c), - RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c), - Sticker(c) => conv(Sticker, Self::Sticker, c), - CustomRoom(c) => Ok(Self::CustomRoom(c)), - CustomState(c) => Ok(Self::CustomState(c)), + CallAnswer(c) => conv(CallAnswer, RoomEvent::CallAnswer, c), + CallCandidates(c) => conv(CallCandidates, RoomEvent::CallCandidates, c), + CallHangup(c) => conv(CallHangup, RoomEvent::CallHangup, c), + CallInvite(c) => conv(CallInvite, RoomEvent::CallInvite, c), + RoomAliases(c) => conv(RoomAliases, RoomEvent::RoomAliases, c), + RoomAvatar(c) => conv(RoomAvatar, RoomEvent::RoomAvatar, c), + RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, RoomEvent::RoomCanonicalAlias, c), + RoomCreate(c) => conv(RoomCreate, RoomEvent::RoomCreate, c), + RoomEncrypted(c) => conv(RoomEncrypted, RoomEvent::RoomEncrypted, c), + RoomEncryption(c) => conv(RoomEncryption, RoomEvent::RoomEncryption, c), + RoomGuestAccess(c) => conv(RoomGuestAccess, RoomEvent::RoomGuestAccess, c), + RoomHistoryVisibility(c) => { + conv(RoomHistoryVisibility, RoomEvent::RoomHistoryVisibility, c) + } + RoomJoinRules(c) => conv(RoomJoinRules, RoomEvent::RoomJoinRules, c), + RoomMember(c) => conv(RoomMember, RoomEvent::RoomMember, c), + RoomMessage(c) => conv(RoomMessage, RoomEvent::RoomMessage, c), + RoomMessageFeedback(c) => conv(RoomMessageFeedback, RoomEvent::RoomMessageFeedback, c), + RoomName(c) => conv(RoomName, RoomEvent::RoomName, c), + RoomPinnedEvents(c) => conv(RoomPinnedEvents, RoomEvent::RoomPinnedEvents, c), + RoomPowerLevels(c) => conv(RoomPowerLevels, RoomEvent::RoomPowerLevels, c), + RoomRedaction(c) => conv(RoomRedaction, RoomEvent::RoomRedaction, c), + RoomServerAcl(c) => conv(RoomServerAcl, RoomEvent::RoomServerAcl, c), + RoomThirdPartyInvite(c) => { + conv(RoomThirdPartyInvite, RoomEvent::RoomThirdPartyInvite, c) + } + RoomTombstone(c) => conv(RoomTombstone, RoomEvent::RoomTombstone, c), + RoomTopic(c) => conv(RoomTopic, RoomEvent::RoomTopic, c), + Sticker(c) => conv(Sticker, RoomEvent::Sticker, c), + CustomRoom(c) => Ok(RoomEvent::CustomRoom(c)), + CustomState(c) => Ok(RoomEvent::CustomState(c)), } } } @@ -444,23 +454,27 @@ impl TryFromRaw for StateEvent { use raw::StateEvent::*; match raw { - RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c), - RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c), - RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c), - RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c), - RoomEncryption(c) => conv(RoomEncryption, Self::RoomEncryption, c), - RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c), - RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c), - RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c), - RoomMember(c) => conv(RoomMember, Self::RoomMember, c), - RoomName(c) => conv(RoomName, Self::RoomName, c), - RoomPinnedEvents(c) => conv(RoomPinnedEvents, Self::RoomPinnedEvents, c), - RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c), - RoomServerAcl(c) => conv(RoomServerAcl, Self::RoomServerAcl, c), - RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c), - RoomTombstone(c) => conv(RoomTombstone, Self::RoomTombstone, c), - RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c), - CustomState(c) => Ok(Self::CustomState(c)), + RoomAliases(c) => conv(RoomAliases, StateEvent::RoomAliases, c), + RoomAvatar(c) => conv(RoomAvatar, StateEvent::RoomAvatar, c), + RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, StateEvent::RoomCanonicalAlias, c), + RoomCreate(c) => conv(RoomCreate, StateEvent::RoomCreate, c), + RoomEncryption(c) => conv(RoomEncryption, StateEvent::RoomEncryption, c), + RoomGuestAccess(c) => conv(RoomGuestAccess, StateEvent::RoomGuestAccess, c), + RoomHistoryVisibility(c) => { + conv(RoomHistoryVisibility, StateEvent::RoomHistoryVisibility, c) + } + RoomJoinRules(c) => conv(RoomJoinRules, StateEvent::RoomJoinRules, c), + RoomMember(c) => conv(RoomMember, StateEvent::RoomMember, c), + RoomName(c) => conv(RoomName, StateEvent::RoomName, c), + RoomPinnedEvents(c) => conv(RoomPinnedEvents, StateEvent::RoomPinnedEvents, c), + RoomPowerLevels(c) => conv(RoomPowerLevels, StateEvent::RoomPowerLevels, c), + RoomServerAcl(c) => conv(RoomServerAcl, StateEvent::RoomServerAcl, c), + RoomThirdPartyInvite(c) => { + conv(RoomThirdPartyInvite, StateEvent::RoomThirdPartyInvite, c) + } + RoomTombstone(c) => conv(RoomTombstone, StateEvent::RoomTombstone, c), + RoomTopic(c) => conv(RoomTopic, StateEvent::RoomTopic, c), + CustomState(c) => Ok(StateEvent::CustomState(c)), } } } diff --git a/src/collections/only.rs b/src/collections/only.rs index f8b29376..e4741abd 100644 --- a/src/collections/only.rs +++ b/src/collections/only.rs @@ -139,27 +139,31 @@ impl TryFromRaw for Event { use raw::Event::*; match raw { - Direct(c) => conv(Direct, Self::Direct, c), - Dummy(c) => conv(Dummy, Self::Dummy, c), - ForwardedRoomKey(c) => conv(ForwardedRoomKey, Self::ForwardedRoomKey, c), - FullyRead(c) => conv(FullyRead, Self::FullyRead, c), - KeyVerificationAccept(c) => conv(KeyVerificationAccept, Self::KeyVerificationAccept, c), - KeyVerificationCancel(c) => conv(KeyVerificationCancel, Self::KeyVerificationCancel, c), - KeyVerificationKey(c) => conv(KeyVerificationKey, Self::KeyVerificationKey, c), - KeyVerificationMac(c) => conv(KeyVerificationMac, Self::KeyVerificationMac, c), - KeyVerificationRequest(c) => { - conv(KeyVerificationRequest, Self::KeyVerificationRequest, c) + Direct(c) => conv(Direct, Event::Direct, c), + Dummy(c) => conv(Dummy, Event::Dummy, c), + ForwardedRoomKey(c) => conv(ForwardedRoomKey, Event::ForwardedRoomKey, c), + FullyRead(c) => conv(FullyRead, Event::FullyRead, c), + KeyVerificationAccept(c) => { + conv(KeyVerificationAccept, Event::KeyVerificationAccept, c) } - KeyVerificationStart(c) => conv(KeyVerificationStart, Self::KeyVerificationStart, c), - IgnoredUserList(c) => conv(IgnoredUserList, Self::IgnoredUserList, c), - Presence(c) => conv(Presence, Self::Presence, c), - PushRules(c) => conv(PushRules, Self::PushRules, c), - RoomKey(c) => conv(RoomKey, Self::RoomKey, c), - RoomKeyRequest(c) => conv(RoomKeyRequest, Self::RoomKeyRequest, c), - Receipt(c) => conv(Receipt, Self::Receipt, c), - Tag(c) => conv(Tag, Self::Tag, c), - Typing(c) => conv(Typing, Self::Typing, c), - Custom(c) => Ok(Self::Custom(c)), + KeyVerificationCancel(c) => { + conv(KeyVerificationCancel, Event::KeyVerificationCancel, c) + } + KeyVerificationKey(c) => conv(KeyVerificationKey, Event::KeyVerificationKey, c), + KeyVerificationMac(c) => conv(KeyVerificationMac, Event::KeyVerificationMac, c), + KeyVerificationRequest(c) => { + conv(KeyVerificationRequest, Event::KeyVerificationRequest, c) + } + KeyVerificationStart(c) => conv(KeyVerificationStart, Event::KeyVerificationStart, c), + IgnoredUserList(c) => conv(IgnoredUserList, Event::IgnoredUserList, c), + Presence(c) => conv(Presence, Event::Presence, c), + PushRules(c) => conv(PushRules, Event::PushRules, c), + RoomKey(c) => conv(RoomKey, Event::RoomKey, c), + RoomKeyRequest(c) => conv(RoomKeyRequest, Event::RoomKeyRequest, c), + Receipt(c) => conv(Receipt, Event::Receipt, c), + Tag(c) => conv(Tag, Event::Tag, c), + Typing(c) => conv(Typing, Event::Typing, c), + Custom(c) => Ok(Event::Custom(c)), } } } @@ -173,16 +177,16 @@ impl TryFromRaw for RoomEvent { use raw::RoomEvent::*; match raw { - CallAnswer(c) => conv(CallAnswer, Self::CallAnswer, c), - CallCandidates(c) => conv(CallCandidates, Self::CallCandidates, c), - CallHangup(c) => conv(CallHangup, Self::CallHangup, c), - CallInvite(c) => conv(CallInvite, Self::CallInvite, c), - RoomEncrypted(c) => conv(RoomEncrypted, Self::RoomEncrypted, c), - RoomMessage(c) => conv(RoomMessage, Self::RoomMessage, c), - RoomMessageFeedback(c) => conv(RoomMessageFeedback, Self::RoomMessageFeedback, c), - RoomRedaction(c) => conv(RoomRedaction, Self::RoomRedaction, c), - Sticker(c) => conv(Sticker, Self::Sticker, c), - CustomRoom(c) => Ok(Self::CustomRoom(c)), + CallAnswer(c) => conv(CallAnswer, RoomEvent::CallAnswer, c), + CallCandidates(c) => conv(CallCandidates, RoomEvent::CallCandidates, c), + CallHangup(c) => conv(CallHangup, RoomEvent::CallHangup, c), + CallInvite(c) => conv(CallInvite, RoomEvent::CallInvite, c), + RoomEncrypted(c) => conv(RoomEncrypted, RoomEvent::RoomEncrypted, c), + RoomMessage(c) => conv(RoomMessage, RoomEvent::RoomMessage, c), + RoomMessageFeedback(c) => conv(RoomMessageFeedback, RoomEvent::RoomMessageFeedback, c), + RoomRedaction(c) => conv(RoomRedaction, RoomEvent::RoomRedaction, c), + Sticker(c) => conv(Sticker, RoomEvent::Sticker, c), + CustomRoom(c) => Ok(RoomEvent::CustomRoom(c)), } } } diff --git a/src/collections/raw/all.rs b/src/collections/raw/all.rs index c4e740f7..6f61e5a4 100644 --- a/src/collections/raw/all.rs +++ b/src/collections/raw/all.rs @@ -347,85 +347,95 @@ impl<'de> Deserialize<'de> for Event { let event_type = get_field(&value, "type")?; match event_type { - CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err), + CallAnswer => from_value(value).map(Event::CallAnswer).map_err(conv_err), CallCandidates => from_value(value) - .map(Self::CallCandidates) + .map(Event::CallCandidates) .map_err(conv_err), - CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err), - CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err), - Direct => from_value(value).map(Self::Direct).map_err(conv_err), - Dummy => from_value(value).map(Self::Dummy).map_err(conv_err), + CallHangup => from_value(value).map(Event::CallHangup).map_err(conv_err), + CallInvite => from_value(value).map(Event::CallInvite).map_err(conv_err), + Direct => from_value(value).map(Event::Direct).map_err(conv_err), + Dummy => from_value(value).map(Event::Dummy).map_err(conv_err), ForwardedRoomKey => from_value(value) - .map(Self::ForwardedRoomKey) + .map(Event::ForwardedRoomKey) .map_err(conv_err), - FullyRead => from_value(value).map(Self::FullyRead).map_err(conv_err), + FullyRead => from_value(value).map(Event::FullyRead).map_err(conv_err), IgnoredUserList => from_value(value) - .map(Self::IgnoredUserList) + .map(Event::IgnoredUserList) .map_err(conv_err), KeyVerificationAccept => from_value(value) - .map(Self::KeyVerificationAccept) + .map(Event::KeyVerificationAccept) .map_err(conv_err), KeyVerificationCancel => from_value(value) - .map(Self::KeyVerificationCancel) + .map(Event::KeyVerificationCancel) .map_err(conv_err), KeyVerificationKey => from_value(value) - .map(Self::KeyVerificationKey) + .map(Event::KeyVerificationKey) .map_err(conv_err), KeyVerificationMac => from_value(value) - .map(Self::KeyVerificationMac) + .map(Event::KeyVerificationMac) .map_err(conv_err), KeyVerificationRequest => from_value(value) - .map(Self::KeyVerificationRequest) + .map(Event::KeyVerificationRequest) .map_err(conv_err), KeyVerificationStart => from_value(value) - .map(Self::KeyVerificationStart) + .map(Event::KeyVerificationStart) .map_err(conv_err), - Presence => from_value(value).map(Self::Presence).map_err(conv_err), - PushRules => from_value(value).map(Self::PushRules).map_err(conv_err), - Receipt => from_value(value).map(Self::Receipt).map_err(conv_err), - RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err), - RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err), + Presence => from_value(value).map(Event::Presence).map_err(conv_err), + PushRules => from_value(value).map(Event::PushRules).map_err(conv_err), + Receipt => from_value(value).map(Event::Receipt).map_err(conv_err), + RoomAliases => from_value(value).map(Event::RoomAliases).map_err(conv_err), + RoomAvatar => from_value(value).map(Event::RoomAvatar).map_err(conv_err), RoomCanonicalAlias => from_value(value) - .map(Self::RoomCanonicalAlias) + .map(Event::RoomCanonicalAlias) + .map_err(conv_err), + RoomCreate => from_value(value).map(Event::RoomCreate).map_err(conv_err), + RoomEncrypted => from_value(value) + .map(Event::RoomEncrypted) .map_err(conv_err), - RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err), - RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err), RoomEncryption => from_value(value) - .map(Self::RoomEncryption) + .map(Event::RoomEncryption) .map_err(conv_err), RoomGuestAccess => from_value(value) - .map(Self::RoomGuestAccess) + .map(Event::RoomGuestAccess) .map_err(conv_err), RoomHistoryVisibility => from_value(value) - .map(Self::RoomHistoryVisibility) + .map(Event::RoomHistoryVisibility) .map_err(conv_err), - RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err), - RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err), - RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err), + RoomJoinRules => from_value(value) + .map(Event::RoomJoinRules) + .map_err(conv_err), + RoomMember => from_value(value).map(Event::RoomMember).map_err(conv_err), + RoomMessage => from_value(value).map(Event::RoomMessage).map_err(conv_err), RoomMessageFeedback => from_value(value) - .map(Self::RoomMessageFeedback) + .map(Event::RoomMessageFeedback) .map_err(conv_err), - RoomName => from_value(value).map(Self::RoomName).map_err(conv_err), + RoomName => from_value(value).map(Event::RoomName).map_err(conv_err), RoomPinnedEvents => from_value(value) - .map(Self::RoomPinnedEvents) + .map(Event::RoomPinnedEvents) .map_err(conv_err), RoomPowerLevels => from_value(value) - .map(Self::RoomPowerLevels) + .map(Event::RoomPowerLevels) + .map_err(conv_err), + RoomRedaction => from_value(value) + .map(Event::RoomRedaction) + .map_err(conv_err), + RoomServerAcl => from_value(value) + .map(Event::RoomServerAcl) .map_err(conv_err), - RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err), - RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err), RoomThirdPartyInvite => from_value(value) - .map(Self::RoomThirdPartyInvite) + .map(Event::RoomThirdPartyInvite) .map_err(conv_err), - RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err), - RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err), - RoomKey => from_value(value).map(Self::RoomKey).map_err(conv_err), + RoomTombstone => from_value(value) + .map(Event::RoomTombstone) + .map_err(conv_err), + RoomTopic => from_value(value).map(Event::RoomTopic).map_err(conv_err), + RoomKey => from_value(value).map(Event::RoomKey).map_err(conv_err), RoomKeyRequest => from_value(value) - .map(Self::RoomKeyRequest) + .map(Event::RoomKeyRequest) .map_err(conv_err), - Sticker => from_value(value).map(Self::Sticker).map_err(conv_err), - Tag => from_value(value).map(Self::Tag).map_err(conv_err), - Typing => from_value(value).map(Self::Typing).map_err(conv_err), + Sticker => from_value(value).map(Event::Sticker).map_err(conv_err), + Tag => from_value(value).map(Event::Tag).map_err(conv_err), + Typing => from_value(value).map(Event::Typing).map_err(conv_err), // TODO Custom(_event_type_name) => Err(D::Error::custom("invalid event type")), __Nonexhaustive => { @@ -446,49 +456,77 @@ impl<'de> Deserialize<'de> for RoomEvent { let event_type = get_field(&value, "type")?; match event_type { - CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err), + CallAnswer => from_value(value) + .map(RoomEvent::CallAnswer) + .map_err(conv_err), CallCandidates => from_value(value) - .map(Self::CallCandidates) + .map(RoomEvent::CallCandidates) + .map_err(conv_err), + CallHangup => from_value(value) + .map(RoomEvent::CallHangup) + .map_err(conv_err), + CallInvite => from_value(value) + .map(RoomEvent::CallInvite) + .map_err(conv_err), + RoomAliases => from_value(value) + .map(RoomEvent::RoomAliases) + .map_err(conv_err), + RoomAvatar => from_value(value) + .map(RoomEvent::RoomAvatar) .map_err(conv_err), - CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err), - CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err), - RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err), - RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err), RoomCanonicalAlias => from_value(value) - .map(Self::RoomCanonicalAlias) + .map(RoomEvent::RoomCanonicalAlias) + .map_err(conv_err), + RoomCreate => from_value(value) + .map(RoomEvent::RoomCreate) + .map_err(conv_err), + RoomEncrypted => from_value(value) + .map(RoomEvent::RoomEncrypted) .map_err(conv_err), - RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err), - RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err), RoomEncryption => from_value(value) - .map(Self::RoomEncryption) + .map(RoomEvent::RoomEncryption) .map_err(conv_err), RoomGuestAccess => from_value(value) - .map(Self::RoomGuestAccess) + .map(RoomEvent::RoomGuestAccess) .map_err(conv_err), RoomHistoryVisibility => from_value(value) - .map(Self::RoomHistoryVisibility) + .map(RoomEvent::RoomHistoryVisibility) + .map_err(conv_err), + RoomJoinRules => from_value(value) + .map(RoomEvent::RoomJoinRules) + .map_err(conv_err), + RoomMember => from_value(value) + .map(RoomEvent::RoomMember) + .map_err(conv_err), + RoomMessage => from_value(value) + .map(RoomEvent::RoomMessage) .map_err(conv_err), - RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err), - RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err), - RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err), RoomMessageFeedback => from_value(value) - .map(Self::RoomMessageFeedback) + .map(RoomEvent::RoomMessageFeedback) .map_err(conv_err), - RoomName => from_value(value).map(Self::RoomName).map_err(conv_err), + RoomName => from_value(value).map(RoomEvent::RoomName).map_err(conv_err), RoomPinnedEvents => from_value(value) - .map(Self::RoomPinnedEvents) + .map(RoomEvent::RoomPinnedEvents) .map_err(conv_err), RoomPowerLevels => from_value(value) - .map(Self::RoomPowerLevels) + .map(RoomEvent::RoomPowerLevels) + .map_err(conv_err), + RoomRedaction => from_value(value) + .map(RoomEvent::RoomRedaction) + .map_err(conv_err), + RoomServerAcl => from_value(value) + .map(RoomEvent::RoomServerAcl) .map_err(conv_err), - RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err), - RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err), RoomThirdPartyInvite => from_value(value) - .map(Self::RoomThirdPartyInvite) + .map(RoomEvent::RoomThirdPartyInvite) .map_err(conv_err), - RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err), - RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err), - Sticker => from_value(value).map(Self::Sticker).map_err(conv_err), + RoomTombstone => from_value(value) + .map(RoomEvent::RoomTombstone) + .map_err(conv_err), + RoomTopic => from_value(value) + .map(RoomEvent::RoomTopic) + .map_err(conv_err), + Sticker => from_value(value).map(RoomEvent::Sticker).map_err(conv_err), //Custom(_event_type_name) => unimplemented!("todo"), _ => Err(D::Error::custom("invalid event type")), } @@ -506,36 +544,54 @@ impl<'de> Deserialize<'de> for StateEvent { let event_type = get_field(&value, "type")?; match event_type { - RoomAliases => from_value(value).map(Self::RoomAliases).map_err(conv_err), - RoomAvatar => from_value(value).map(Self::RoomAvatar).map_err(conv_err), - RoomCanonicalAlias => from_value(value) - .map(Self::RoomCanonicalAlias) + RoomAliases => from_value(value) + .map(StateEvent::RoomAliases) + .map_err(conv_err), + RoomAvatar => from_value(value) + .map(StateEvent::RoomAvatar) + .map_err(conv_err), + RoomCanonicalAlias => from_value(value) + .map(StateEvent::RoomCanonicalAlias) + .map_err(conv_err), + RoomCreate => from_value(value) + .map(StateEvent::RoomCreate) .map_err(conv_err), - RoomCreate => from_value(value).map(Self::RoomCreate).map_err(conv_err), RoomEncryption => from_value(value) - .map(Self::RoomEncryption) + .map(StateEvent::RoomEncryption) .map_err(conv_err), RoomGuestAccess => from_value(value) - .map(Self::RoomGuestAccess) + .map(StateEvent::RoomGuestAccess) .map_err(conv_err), RoomHistoryVisibility => from_value(value) - .map(Self::RoomHistoryVisibility) + .map(StateEvent::RoomHistoryVisibility) + .map_err(conv_err), + RoomJoinRules => from_value(value) + .map(StateEvent::RoomJoinRules) + .map_err(conv_err), + RoomMember => from_value(value) + .map(StateEvent::RoomMember) + .map_err(conv_err), + RoomName => from_value(value) + .map(StateEvent::RoomName) .map_err(conv_err), - RoomJoinRules => from_value(value).map(Self::RoomJoinRules).map_err(conv_err), - RoomMember => from_value(value).map(Self::RoomMember).map_err(conv_err), - RoomName => from_value(value).map(Self::RoomName).map_err(conv_err), RoomPinnedEvents => from_value(value) - .map(Self::RoomPinnedEvents) + .map(StateEvent::RoomPinnedEvents) .map_err(conv_err), RoomPowerLevels => from_value(value) - .map(Self::RoomPowerLevels) + .map(StateEvent::RoomPowerLevels) + .map_err(conv_err), + RoomServerAcl => from_value(value) + .map(StateEvent::RoomServerAcl) .map_err(conv_err), - RoomServerAcl => from_value(value).map(Self::RoomServerAcl).map_err(conv_err), RoomThirdPartyInvite => from_value(value) - .map(Self::RoomThirdPartyInvite) + .map(StateEvent::RoomThirdPartyInvite) + .map_err(conv_err), + RoomTombstone => from_value(value) + .map(StateEvent::RoomTombstone) + .map_err(conv_err), + RoomTopic => from_value(value) + .map(StateEvent::RoomTopic) .map_err(conv_err), - RoomTombstone => from_value(value).map(Self::RoomTombstone).map_err(conv_err), - RoomTopic => from_value(value).map(Self::RoomTopic).map_err(conv_err), //Custom(_event_type_name) => unimplemented!("todo"), _ => Err(D::Error::custom("invalid event type")), } diff --git a/src/collections/raw/only.rs b/src/collections/raw/only.rs index 92395e2c..53a3588e 100644 --- a/src/collections/raw/only.rs +++ b/src/collections/raw/only.rs @@ -154,42 +154,42 @@ impl<'de> Deserialize<'de> for Event { let event_type = get_field(&value, "type")?; match event_type { - Direct => from_value(value).map(Self::Direct).map_err(conv_err), - Dummy => from_value(value).map(Self::Dummy).map_err(conv_err), + Direct => from_value(value).map(Event::Direct).map_err(conv_err), + Dummy => from_value(value).map(Event::Dummy).map_err(conv_err), ForwardedRoomKey => from_value(value) - .map(Self::ForwardedRoomKey) + .map(Event::ForwardedRoomKey) .map_err(conv_err), - FullyRead => from_value(value).map(Self::FullyRead).map_err(conv_err), + FullyRead => from_value(value).map(Event::FullyRead).map_err(conv_err), KeyVerificationAccept => from_value(value) - .map(Self::KeyVerificationAccept) + .map(Event::KeyVerificationAccept) .map_err(conv_err), KeyVerificationCancel => from_value(value) - .map(Self::KeyVerificationCancel) + .map(Event::KeyVerificationCancel) .map_err(conv_err), KeyVerificationKey => from_value(value) - .map(Self::KeyVerificationKey) + .map(Event::KeyVerificationKey) .map_err(conv_err), KeyVerificationMac => from_value(value) - .map(Self::KeyVerificationMac) + .map(Event::KeyVerificationMac) .map_err(conv_err), KeyVerificationRequest => from_value(value) - .map(Self::KeyVerificationRequest) + .map(Event::KeyVerificationRequest) .map_err(conv_err), KeyVerificationStart => from_value(value) - .map(Self::KeyVerificationStart) + .map(Event::KeyVerificationStart) .map_err(conv_err), IgnoredUserList => from_value(value) - .map(Self::IgnoredUserList) + .map(Event::IgnoredUserList) .map_err(conv_err), - Presence => from_value(value).map(Self::Presence).map_err(conv_err), - PushRules => from_value(value).map(Self::PushRules).map_err(conv_err), - RoomKey => from_value(value).map(Self::RoomKey).map_err(conv_err), + Presence => from_value(value).map(Event::Presence).map_err(conv_err), + PushRules => from_value(value).map(Event::PushRules).map_err(conv_err), + RoomKey => from_value(value).map(Event::RoomKey).map_err(conv_err), RoomKeyRequest => from_value(value) - .map(Self::RoomKeyRequest) + .map(Event::RoomKeyRequest) .map_err(conv_err), - Receipt => from_value(value).map(Self::Receipt).map_err(conv_err), - Tag => from_value(value).map(Self::Tag).map_err(conv_err), - Typing => from_value(value).map(Self::Typing).map_err(conv_err), + Receipt => from_value(value).map(Event::Receipt).map_err(conv_err), + Tag => from_value(value).map(Event::Tag).map_err(conv_err), + Typing => from_value(value).map(Event::Typing).map_err(conv_err), //Custom(_event_type_name) => unimplemented!("todo"), _ => Err(D::Error::custom("invalid event type")), } @@ -207,19 +207,31 @@ impl<'de> Deserialize<'de> for RoomEvent { let event_type = get_field(&value, "type")?; match event_type { - CallAnswer => from_value(value).map(Self::CallAnswer).map_err(conv_err), + CallAnswer => from_value(value) + .map(RoomEvent::CallAnswer) + .map_err(conv_err), CallCandidates => from_value(value) - .map(Self::CallCandidates) + .map(RoomEvent::CallCandidates) + .map_err(conv_err), + CallHangup => from_value(value) + .map(RoomEvent::CallHangup) + .map_err(conv_err), + CallInvite => from_value(value) + .map(RoomEvent::CallInvite) + .map_err(conv_err), + RoomEncrypted => from_value(value) + .map(RoomEvent::RoomEncrypted) + .map_err(conv_err), + RoomMessage => from_value(value) + .map(RoomEvent::RoomMessage) .map_err(conv_err), - CallHangup => from_value(value).map(Self::CallHangup).map_err(conv_err), - CallInvite => from_value(value).map(Self::CallInvite).map_err(conv_err), - RoomEncrypted => from_value(value).map(Self::RoomEncrypted).map_err(conv_err), - RoomMessage => from_value(value).map(Self::RoomMessage).map_err(conv_err), RoomMessageFeedback => from_value(value) - .map(Self::RoomMessageFeedback) + .map(RoomEvent::RoomMessageFeedback) .map_err(conv_err), - RoomRedaction => from_value(value).map(Self::RoomRedaction).map_err(conv_err), - Sticker => from_value(value).map(Self::Sticker).map_err(conv_err), + RoomRedaction => from_value(value) + .map(RoomEvent::RoomRedaction) + .map_err(conv_err), + Sticker => from_value(value).map(RoomEvent::Sticker).map_err(conv_err), //Custom(_event_type_name) => unimplemented!("todo"), _ => Err(D::Error::custom("invalid event type")), } diff --git a/src/key/verification/start.rs b/src/key/verification/start.rs index b06174ff..53befab0 100644 --- a/src/key/verification/start.rs +++ b/src/key/verification/start.rs @@ -1,7 +1,7 @@ //! Types for the *m.key.verification.start* event. use ruma_identifiers::DeviceId; -use serde::{de::Error, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer}; +use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer}; use serde_json::{from_value, Value}; use super::{ @@ -157,6 +157,8 @@ pub(crate) mod raw { where D: Deserializer<'de>, { + use serde::de::Error as _; + let value: Value = Deserialize::deserialize(deserializer)?; let method_value = match value.get("method") { diff --git a/src/lib.rs b/src/lib.rs index 85186e3d..2262753e 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -128,9 +128,7 @@ use serde::{ }; use serde_json::Value; -pub use custom::CustomEvent; -pub use custom_room::CustomRoomEvent; -pub use custom_state::CustomStateEvent; +pub use self::{custom::CustomEvent, custom_room::CustomRoomEvent, custom_state::CustomStateEvent}; #[macro_use] mod macros; diff --git a/src/room/encrypted.rs b/src/room/encrypted.rs index d10e0d02..4ea182ab 100644 --- a/src/room/encrypted.rs +++ b/src/room/encrypted.rs @@ -2,7 +2,7 @@ use js_int::UInt; use ruma_identifiers::{DeviceId, EventId, RoomId, UserId}; -use serde::{de::Error, ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer}; +use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer}; use serde_json::{from_value, Value}; use crate::{Algorithm, Event, EventType, FromRaw}; @@ -70,8 +70,10 @@ impl FromRaw for EncryptedEventContent { use raw::EncryptedEventContent::*; match raw { - OlmV1Curve25519AesSha2(content) => Self::OlmV1Curve25519AesSha2(content), - MegolmV1AesSha2(content) => Self::MegolmV1AesSha2(content), + OlmV1Curve25519AesSha2(content) => { + EncryptedEventContent::OlmV1Curve25519AesSha2(content) + } + MegolmV1AesSha2(content) => EncryptedEventContent::MegolmV1AesSha2(content), __Nonexhaustive => { unreachable!("__Nonexhaustive variant should be impossible to obtain.") } @@ -185,6 +187,8 @@ pub(crate) mod raw { where D: Deserializer<'de>, { + use serde::de::Error as _; + let value: Value = Deserialize::deserialize(deserializer)?; let method_value = match value.get("algorithm") { diff --git a/src/room/message.rs b/src/room/message.rs index 9565f939..2e5824f4 100644 --- a/src/room/message.rs +++ b/src/room/message.rs @@ -2,11 +2,7 @@ use js_int::UInt; use ruma_identifiers::{EventId, RoomId, UserId}; -use serde::{ - de::Error as _, - ser::{Error as _, SerializeStruct}, - Deserialize, Deserializer, Serialize, Serializer, -}; +use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer}; use serde_json::{from_value, Value}; use super::{EncryptedFile, ImageInfo, ThumbnailInfo}; @@ -96,15 +92,15 @@ impl FromRaw for MessageEventContent { use raw::MessageEventContent::*; match raw { - Audio(content) => Self::Audio(content), - Emote(content) => Self::Emote(content), - File(content) => Self::File(content), - Image(content) => Self::Image(content), - Location(content) => Self::Location(content), - Notice(content) => Self::Notice(content), - ServerNotice(content) => Self::ServerNotice(content), - Text(content) => Self::Text(content), - Video(content) => Self::Video(content), + Audio(content) => MessageEventContent::Audio(content), + Emote(content) => MessageEventContent::Emote(content), + File(content) => MessageEventContent::File(content), + Image(content) => MessageEventContent::Image(content), + Location(content) => MessageEventContent::Location(content), + Notice(content) => MessageEventContent::Notice(content), + ServerNotice(content) => MessageEventContent::ServerNotice(content), + Text(content) => MessageEventContent::Text(content), + Video(content) => MessageEventContent::Video(content), __Nonexhaustive => { unreachable!("It should be impossible to obtain a __Nonexhaustive variant.") } @@ -155,6 +151,8 @@ impl Serialize for MessageEventContent { where S: Serializer, { + use serde::ser::Error as _; + match *self { MessageEventContent::Audio(ref content) => content.serialize(serializer), MessageEventContent::Emote(ref content) => content.serialize(serializer), @@ -240,6 +238,8 @@ pub(crate) mod raw { where D: Deserializer<'de>, { + use serde::de::Error as _; + let value: Value = Deserialize::deserialize(deserializer)?; let message_type_value = match value.get("msgtype") { diff --git a/src/stripped.rs b/src/stripped.rs index 5f4f71ce..310d25f2 100644 --- a/src/stripped.rs +++ b/src/stripped.rs @@ -126,18 +126,24 @@ impl TryFromRaw for StrippedState { use raw::StrippedState::*; match raw { - RoomAliases(c) => conv(RoomAliases, Self::RoomAliases, c), - RoomAvatar(c) => conv(RoomAvatar, Self::RoomAvatar, c), - RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, Self::RoomCanonicalAlias, c), - RoomCreate(c) => conv(RoomCreate, Self::RoomCreate, c), - RoomGuestAccess(c) => conv(RoomGuestAccess, Self::RoomGuestAccess, c), - RoomHistoryVisibility(c) => conv(RoomHistoryVisibility, Self::RoomHistoryVisibility, c), - RoomJoinRules(c) => conv(RoomJoinRules, Self::RoomJoinRules, c), - RoomMember(c) => conv(RoomMember, Self::RoomMember, c), - RoomName(c) => conv(RoomName, Self::RoomName, c), - RoomPowerLevels(c) => conv(RoomPowerLevels, Self::RoomPowerLevels, c), - RoomThirdPartyInvite(c) => conv(RoomThirdPartyInvite, Self::RoomThirdPartyInvite, c), - RoomTopic(c) => conv(RoomTopic, Self::RoomTopic, c), + RoomAliases(c) => conv(RoomAliases, StrippedState::RoomAliases, c), + RoomAvatar(c) => conv(RoomAvatar, StrippedState::RoomAvatar, c), + RoomCanonicalAlias(c) => conv(RoomCanonicalAlias, StrippedState::RoomCanonicalAlias, c), + RoomCreate(c) => conv(RoomCreate, StrippedState::RoomCreate, c), + RoomGuestAccess(c) => conv(RoomGuestAccess, StrippedState::RoomGuestAccess, c), + RoomHistoryVisibility(c) => conv( + RoomHistoryVisibility, + StrippedState::RoomHistoryVisibility, + c, + ), + RoomJoinRules(c) => conv(RoomJoinRules, StrippedState::RoomJoinRules, c), + RoomMember(c) => conv(RoomMember, StrippedState::RoomMember, c), + RoomName(c) => conv(RoomName, StrippedState::RoomName, c), + RoomPowerLevels(c) => conv(RoomPowerLevels, StrippedState::RoomPowerLevels, c), + RoomThirdPartyInvite(c) => { + conv(RoomThirdPartyInvite, StrippedState::RoomThirdPartyInvite, c) + } + RoomTopic(c) => conv(RoomTopic, StrippedState::RoomTopic, c), } } } @@ -210,6 +216,7 @@ where mod raw { use serde::{Deserialize, Deserializer}; + use serde_json::Value; use super::StrippedStateContent; use crate::room::{ @@ -304,44 +311,56 @@ mod raw { where D: Deserializer<'de>, { - use crate::EventType::*; + use crate::{ + util::{get_field, serde_json_error_to_generic_de_error as conv_err}, + EventType::*, + }; use serde::de::Error as _; - use serde_json::{from_value, Value}; - - let conv_err = |error: serde_json::Error| D::Error::custom(error.to_string()); + use serde_json::from_value; // TODO: Optimize let value = Value::deserialize(deserializer)?; + let event_type = get_field(&value, "type")?; - let event_type = from_value( - value - .get("type") - .cloned() - .ok_or_else(|| D::Error::missing_field("type"))?, - ) - .map_err(conv_err)?; - - Ok(match event_type { - RoomAliases => StrippedState::RoomAliases(from_value(value).map_err(conv_err)?), - RoomAvatar => Self::RoomAvatar(from_value(value).map_err(conv_err)?), - RoomCanonicalAlias => { - Self::RoomCanonicalAlias(from_value(value).map_err(conv_err)?) - } - RoomCreate => Self::RoomCreate(from_value(value).map_err(conv_err)?), - RoomGuestAccess => Self::RoomGuestAccess(from_value(value).map_err(conv_err)?), - RoomHistoryVisibility => { - Self::RoomHistoryVisibility(from_value(value).map_err(conv_err)?) - } - RoomJoinRules => Self::RoomJoinRules(from_value(value).map_err(conv_err)?), - RoomMember => Self::RoomMember(from_value(value).map_err(conv_err)?), - RoomName => Self::RoomName(from_value(value).map_err(conv_err)?), - RoomPowerLevels => Self::RoomPowerLevels(from_value(value).map_err(conv_err)?), - RoomThirdPartyInvite => { - Self::RoomThirdPartyInvite(from_value(value).map_err(conv_err)?) - } - RoomTopic => Self::RoomTopic(from_value(value).map_err(conv_err)?), - _ => return Err(D::Error::custom("not a state event")), - }) + match event_type { + RoomAliases => from_value(value) + .map(StrippedState::RoomAliases) + .map_err(conv_err), + RoomAvatar => from_value(value) + .map(StrippedState::RoomAvatar) + .map_err(conv_err), + RoomCanonicalAlias => from_value(value) + .map(StrippedState::RoomCanonicalAlias) + .map_err(conv_err), + RoomCreate => from_value(value) + .map(StrippedState::RoomCreate) + .map_err(conv_err), + RoomGuestAccess => from_value(value) + .map(StrippedState::RoomGuestAccess) + .map_err(conv_err), + RoomHistoryVisibility => from_value(value) + .map(StrippedState::RoomHistoryVisibility) + .map_err(conv_err), + RoomJoinRules => from_value(value) + .map(StrippedState::RoomJoinRules) + .map_err(conv_err), + RoomMember => from_value(value) + .map(StrippedState::RoomMember) + .map_err(conv_err), + RoomName => from_value(value) + .map(StrippedState::RoomName) + .map_err(conv_err), + RoomPowerLevels => from_value(value) + .map(StrippedState::RoomPowerLevels) + .map_err(conv_err), + RoomThirdPartyInvite => from_value(value) + .map(StrippedState::RoomThirdPartyInvite) + .map_err(conv_err), + RoomTopic => from_value(value) + .map(StrippedState::RoomTopic) + .map_err(conv_err), + _ => Err(D::Error::custom("not a state event")), + } } } }