Struct Selector 

pub struct Selector<'a, T> { /* private fields */ }

Implementations

impl<'a> Selector<'a, MessageEventPrivate>

pub fn filter(&mut self, f: impl FnOnce(&MessageEventPrivate) -> bool)

pub fn and_filter(self, f: impl FnOnce(&MessageEventPrivate) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&MessageEventPrivate) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&MessageEventPrivate) -> bool, ) -> Self

pub fn filter_sub_type(&mut self, f: impl FnOnce(PrivateMessageSubType) -> bool)

pub fn and_filter_sub_type( self, f: impl FnOnce(PrivateMessageSubType) -> bool, ) -> Self

pub async fn filter_sub_type_async( &mut self, f: impl AsyncFnOnce(PrivateMessageSubType) -> bool, )

pub async fn and_filter_sub_type_async( self, f: impl AsyncFnOnce(PrivateMessageSubType) -> bool, ) -> Self

pub fn filter_message_id(&mut self, f: impl FnOnce(i32) -> bool)

pub fn and_filter_message_id(self, f: impl FnOnce(i32) -> bool) -> Self

pub async fn filter_message_id_async( &mut self, f: impl AsyncFnOnce(i32) -> bool, )

pub async fn and_filter_message_id_async( self, f: impl AsyncFnOnce(i32) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_message(&mut self, f: impl FnOnce(&Vec<ReceiveSegment>) -> bool)

pub fn and_filter_message( self, f: impl FnOnce(&Vec<ReceiveSegment>) -> bool, ) -> Self

pub async fn filter_message_async( &mut self, f: impl AsyncFnOnce(&Vec<ReceiveSegment>) -> bool, )

pub async fn and_filter_message_async( self, f: impl AsyncFnOnce(&Vec<ReceiveSegment>) -> bool, ) -> Self

pub fn filter_raw_message(&mut self, f: impl FnOnce(&str) -> bool)

pub fn and_filter_raw_message(self, f: impl FnOnce(&str) -> bool) -> Self

pub async fn filter_raw_message_async( &mut self, f: impl AsyncFnOnce(&str) -> bool, )

pub async fn and_filter_raw_message_async( self, f: impl AsyncFnOnce(&str) -> bool, ) -> Self

pub fn filter_font(&mut self, f: impl FnOnce(i32) -> bool)

pub fn and_filter_font(self, f: impl FnOnce(i32) -> bool) -> Self

pub async fn filter_font_async(&mut self, f: impl AsyncFnOnce(i32) -> bool)

pub async fn and_filter_font_async( self, f: impl AsyncFnOnce(i32) -> bool, ) -> Self

pub fn filter_sender(&mut self, f: impl FnOnce(&PrivateMessageSender) -> bool)

pub fn and_filter_sender( self, f: impl FnOnce(&PrivateMessageSender) -> bool, ) -> Self

pub async fn filter_sender_async( &mut self, f: impl AsyncFnOnce(&PrivateMessageSender) -> bool, )

pub async fn and_filter_sender_async( self, f: impl AsyncFnOnce(&PrivateMessageSender) -> bool, ) -> Self

pub fn friend(&mut self)

pub fn and_friend(self) -> Self

pub fn not_friend(&mut self)

pub fn and_not_friend(self) -> Self

pub fn group(&mut self)

pub fn and_group(self) -> Self

pub fn not_group(&mut self)

pub fn and_not_group(self) -> Self

pub fn other(&mut self)

pub fn and_other(self) -> Self

pub fn not_other(&mut self)

pub fn and_not_other(self) -> Self

impl<'a> Selector<'a, MessageEventGroup>

pub fn filter(&mut self, f: impl FnOnce(&MessageEventGroup) -> bool)

pub fn and_filter(self, f: impl FnOnce(&MessageEventGroup) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&MessageEventGroup) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&MessageEventGroup) -> bool, ) -> Self

pub fn filter_sub_type(&mut self, f: impl FnOnce(GroupMessageSubType) -> bool)

pub fn and_filter_sub_type( self, f: impl FnOnce(GroupMessageSubType) -> bool, ) -> Self

pub async fn filter_sub_type_async( &mut self, f: impl AsyncFnOnce(GroupMessageSubType) -> bool, )

pub async fn and_filter_sub_type_async( self, f: impl AsyncFnOnce(GroupMessageSubType) -> bool, ) -> Self

pub fn filter_message_id(&mut self, f: impl FnOnce(i32) -> bool)

pub fn and_filter_message_id(self, f: impl FnOnce(i32) -> bool) -> Self

pub async fn filter_message_id_async( &mut self, f: impl AsyncFnOnce(i32) -> bool, )

pub async fn and_filter_message_id_async( self, f: impl AsyncFnOnce(i32) -> bool, ) -> Self

pub fn filter_group_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_group_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_group_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_group_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_anonymous( &mut self, f: impl FnOnce(&Option<GroupMessageAnonymous>) -> bool, )

pub fn and_filter_anonymous( self, f: impl FnOnce(&Option<GroupMessageAnonymous>) -> bool, ) -> Self

pub async fn filter_anonymous_async( &mut self, f: impl AsyncFnOnce(&Option<GroupMessageAnonymous>) -> bool, )

pub async fn and_filter_anonymous_async( self, f: impl AsyncFnOnce(&Option<GroupMessageAnonymous>) -> bool, ) -> Self

pub fn filter_message(&mut self, f: impl FnOnce(&Vec<ReceiveSegment>) -> bool)

pub fn and_filter_message( self, f: impl FnOnce(&Vec<ReceiveSegment>) -> bool, ) -> Self

pub async fn filter_message_async( &mut self, f: impl AsyncFnOnce(&Vec<ReceiveSegment>) -> bool, )

pub async fn and_filter_message_async( self, f: impl AsyncFnOnce(&Vec<ReceiveSegment>) -> bool, ) -> Self

pub fn filter_raw_message(&mut self, f: impl FnOnce(&str) -> bool)

pub fn and_filter_raw_message(self, f: impl FnOnce(&str) -> bool) -> Self

pub async fn filter_raw_message_async( &mut self, f: impl AsyncFnOnce(&str) -> bool, )

pub async fn and_filter_raw_message_async( self, f: impl AsyncFnOnce(&str) -> bool, ) -> Self

pub fn filter_font(&mut self, f: impl FnOnce(i32) -> bool)

pub fn and_filter_font(self, f: impl FnOnce(i32) -> bool) -> Self

pub async fn filter_font_async(&mut self, f: impl AsyncFnOnce(i32) -> bool)

pub async fn and_filter_font_async( self, f: impl AsyncFnOnce(i32) -> bool, ) -> Self

pub fn filter_sender(&mut self, f: impl FnOnce(&GroupMessageSender) -> bool)

pub fn and_filter_sender( self, f: impl FnOnce(&GroupMessageSender) -> bool, ) -> Self

pub async fn filter_sender_async( &mut self, f: impl AsyncFnOnce(&GroupMessageSender) -> bool, )

pub async fn and_filter_sender_async( self, f: impl AsyncFnOnce(&GroupMessageSender) -> bool, ) -> Self

pub fn normal(&mut self)

pub fn and_normal(self) -> Self

pub fn not_normal(&mut self)

pub fn and_not_normal(self) -> Self

pub fn anonymous(&mut self)

pub fn and_anonymous(self) -> Self

pub fn not_anonymous(&mut self)

pub fn and_not_anonymous(self) -> Self

pub fn notice(&mut self)

pub fn and_notice(self) -> Self

pub fn not_notice(&mut self)

pub fn and_not_notice(self) -> Self

impl<'a> Selector<'a, MessageEvent>

pub fn private(&self) -> Selector<'a, MessageEventPrivate>

pub fn group(&self) -> Selector<'a, MessageEventGroup>

impl<'a> Selector<'a, MetaEventLifecycle>

pub fn filter(&mut self, f: impl FnOnce(MetaEventLifecycle) -> bool)

pub fn and_filter(self, f: impl FnOnce(MetaEventLifecycle) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(MetaEventLifecycle) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(MetaEventLifecycle) -> bool, ) -> Self

pub fn filter_sub_type(&mut self, f: impl FnOnce(LifecycleSubType) -> bool)

pub fn and_filter_sub_type( self, f: impl FnOnce(LifecycleSubType) -> bool, ) -> Self

pub async fn filter_sub_type_async( &mut self, f: impl AsyncFnOnce(LifecycleSubType) -> bool, )

pub async fn and_filter_sub_type_async( self, f: impl AsyncFnOnce(LifecycleSubType) -> bool, ) -> Self

pub fn enable(&mut self)

pub fn and_enable(self) -> Self

pub fn not_enable(&mut self)

pub fn and_not_enable(self) -> Self

pub fn disable(&mut self)

pub fn and_disable(self) -> Self

pub fn not_disable(&mut self)

pub fn and_not_disable(self) -> Self

pub fn connect(&mut self)

pub fn and_connect(self) -> Self

pub fn not_connect(&mut self)

pub fn and_not_connect(self) -> Self

impl<'a> Selector<'a, MetaEventHeartbeat>

pub fn filter(&mut self, f: impl FnOnce(&MetaEventHeartbeat) -> bool)

pub fn and_filter(self, f: impl FnOnce(&MetaEventHeartbeat) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&MetaEventHeartbeat) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&MetaEventHeartbeat) -> bool, ) -> Self

pub fn filter_status(&mut self, f: impl FnOnce(&HashMap<String, Value>) -> bool)

pub fn and_filter_status( self, f: impl FnOnce(&HashMap<String, Value>) -> bool, ) -> Self

pub async fn filter_status_async( &mut self, f: impl AsyncFnOnce(&HashMap<String, Value>) -> bool, )

pub async fn and_filter_status_async( self, f: impl AsyncFnOnce(&HashMap<String, Value>) -> bool, ) -> Self

pub fn filter_interval(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_interval(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_interval_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_interval_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

impl<'a> Selector<'a, MetaEvent>

pub fn lifecycle(&self) -> Selector<'a, MetaEventLifecycle>

pub fn heartbeat(&self) -> Selector<'a, MetaEventHeartbeat>

impl<'a> Selector<'a, NoticeEventGroupUpload>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventGroupUpload) -> bool)

pub fn and_filter(self, f: impl FnOnce(&NoticeEventGroupUpload) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventGroupUpload) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventGroupUpload) -> bool, ) -> Self

pub fn filter_group_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_group_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_group_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_group_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_file(&mut self, f: impl FnOnce(&GroupFile) -> bool)

pub fn and_filter_file(self, f: impl FnOnce(&GroupFile) -> bool) -> Self

pub async fn filter_file_async( &mut self, f: impl AsyncFnOnce(&GroupFile) -> bool, )

pub async fn and_filter_file_async( self, f: impl AsyncFnOnce(&GroupFile) -> bool, ) -> Self

impl<'a> Selector<'a, NoticeEventGroupAdmin>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventGroupAdmin) -> bool)

pub fn and_filter(self, f: impl FnOnce(&NoticeEventGroupAdmin) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventGroupAdmin) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventGroupAdmin) -> bool, ) -> Self

pub fn filter_sub_type(&mut self, f: impl FnOnce(GroupAdminType) -> bool)

pub fn and_filter_sub_type(self, f: impl FnOnce(GroupAdminType) -> bool) -> Self

pub async fn filter_sub_type_async( &mut self, f: impl AsyncFnOnce(GroupAdminType) -> bool, )

pub async fn and_filter_sub_type_async( self, f: impl AsyncFnOnce(GroupAdminType) -> bool, ) -> Self

pub fn filter_group_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_group_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_group_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_group_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn set(&mut self)

pub fn and_set(self) -> Self

pub fn not_set(&mut self)

pub fn and_not_set(self) -> Self

pub fn unset(&mut self)

pub fn and_unset(self) -> Self

pub fn not_unset(&mut self)

pub fn and_not_unset(self) -> Self

impl<'a> Selector<'a, NoticeEventGroupDecrease>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventGroupDecrease) -> bool)

pub fn and_filter( self, f: impl FnOnce(&NoticeEventGroupDecrease) -> bool, ) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventGroupDecrease) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventGroupDecrease) -> bool, ) -> Self

pub fn filter_sub_type(&mut self, f: impl FnOnce(GroupDecreaseType) -> bool)

pub fn and_filter_sub_type( self, f: impl FnOnce(GroupDecreaseType) -> bool, ) -> Self

pub async fn filter_sub_type_async( &mut self, f: impl AsyncFnOnce(GroupDecreaseType) -> bool, )

pub async fn and_filter_sub_type_async( self, f: impl AsyncFnOnce(GroupDecreaseType) -> bool, ) -> Self

pub fn filter_operator_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_operator_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_operator_id_async( &mut self, f: impl AsyncFnOnce(i64) -> bool, )

pub async fn and_filter_operator_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn leave(&mut self)

pub fn and_leave(self) -> Self

pub fn not_leave(&mut self)

pub fn and_not_leave(self) -> Self

pub fn kick(&mut self)

pub fn and_kick(self) -> Self

pub fn not_kick(&mut self)

pub fn and_not_kick(self) -> Self

pub fn kick_me(&mut self)

pub fn and_kick_me(self) -> Self

pub fn not_kick_me(&mut self)

pub fn and_not_kick_me(self) -> Self

impl<'a> Selector<'a, NoticeEventGroupIncrease>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventGroupIncrease) -> bool)

pub fn and_filter( self, f: impl FnOnce(&NoticeEventGroupIncrease) -> bool, ) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventGroupIncrease) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventGroupIncrease) -> bool, ) -> Self

pub fn filter_sub_type(&mut self, f: impl FnOnce(GroupIncreaseType) -> bool)

pub fn and_filter_sub_type( self, f: impl FnOnce(GroupIncreaseType) -> bool, ) -> Self

pub async fn filter_sub_type_async( &mut self, f: impl AsyncFnOnce(GroupIncreaseType) -> bool, )

pub async fn and_filter_sub_type_async( self, f: impl AsyncFnOnce(GroupIncreaseType) -> bool, ) -> Self

pub fn filter_group_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_group_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_group_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_group_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_operator_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_operator_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_operator_id_async( &mut self, f: impl AsyncFnOnce(i64) -> bool, )

pub async fn and_filter_operator_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn approve(&mut self)

pub fn and_approve(self) -> Self

pub fn not_approve(&mut self)

pub fn and_not_approve(self) -> Self

pub fn invite(&mut self)

pub fn and_invite(self) -> Self

pub fn not_invite(&mut self)

pub fn and_not_invite(self) -> Self

impl<'a> Selector<'a, NoticeEventGroupBan>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventGroupBan) -> bool)

pub fn and_filter(self, f: impl FnOnce(&NoticeEventGroupBan) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventGroupBan) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventGroupBan) -> bool, ) -> Self

pub fn filter_sub_type(&mut self, f: impl FnOnce(GroupBanType) -> bool)

pub fn and_filter_sub_type(self, f: impl FnOnce(GroupBanType) -> bool) -> Self

pub async fn filter_sub_type_async( &mut self, f: impl AsyncFnOnce(GroupBanType) -> bool, )

pub async fn and_filter_sub_type_async( self, f: impl AsyncFnOnce(GroupBanType) -> bool, ) -> Self

pub fn filter_group_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_group_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_group_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_group_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_operator_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_operator_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_operator_id_async( &mut self, f: impl AsyncFnOnce(i64) -> bool, )

pub async fn and_filter_operator_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_duration(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_duration(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_duration_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_duration_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn ban(&mut self)

pub fn and_ban(self) -> Self

pub fn not_ban(&mut self)

pub fn and_not_ban(self) -> Self

pub fn lift_ban(&mut self)

pub fn and_lift_ban(self) -> Self

pub fn not_lift_ban(&mut self)

pub fn and_not_lift_ban(self) -> Self

impl<'a> Selector<'a, NoticeEventFriendAdd>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventFriendAdd) -> bool)

pub fn and_filter(self, f: impl FnOnce(&NoticeEventFriendAdd) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventFriendAdd) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventFriendAdd) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

impl<'a> Selector<'a, NoticeEventGroupRecall>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventGroupRecall) -> bool)

pub fn and_filter(self, f: impl FnOnce(&NoticeEventGroupRecall) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventGroupRecall) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventGroupRecall) -> bool, ) -> Self

pub fn filter_group_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_group_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_group_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_group_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_operator_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_operator_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_operator_id_async( &mut self, f: impl AsyncFnOnce(i64) -> bool, )

pub async fn and_filter_operator_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_message_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_message_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_message_id_async( &mut self, f: impl AsyncFnOnce(i64) -> bool, )

pub async fn and_filter_message_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

impl<'a> Selector<'a, NoticeEventFriendRecall>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventFriendRecall) -> bool)

pub fn and_filter( self, f: impl FnOnce(&NoticeEventFriendRecall) -> bool, ) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventFriendRecall) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventFriendRecall) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_message_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_message_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_message_id_async( &mut self, f: impl AsyncFnOnce(i64) -> bool, )

pub async fn and_filter_message_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

impl<'a> Selector<'a, NoticeEventNotify>

pub fn filter(&mut self, f: impl FnOnce(&NoticeEventNotify) -> bool)

pub fn and_filter(self, f: impl FnOnce(&NoticeEventNotify) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&NoticeEventNotify) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&NoticeEventNotify) -> bool, ) -> Self

pub fn filter_group_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_group_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_group_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_group_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_data(&mut self, f: impl FnOnce(&NotifyType) -> bool)

pub fn and_filter_data(self, f: impl FnOnce(&NotifyType) -> bool) -> Self

pub async fn filter_data_async( &mut self, f: impl AsyncFnOnce(&NotifyType) -> bool, )

pub async fn and_filter_data_async( self, f: impl AsyncFnOnce(&NotifyType) -> bool, ) -> Self

impl<'a> Selector<'a, NoticeEvent>

pub fn group_upload(&self) -> Selector<'a, NoticeEventGroupUpload>

pub fn group_admin(&self) -> Selector<'a, NoticeEventGroupAdmin>

pub fn group_decrease(&self) -> Selector<'a, NoticeEventGroupDecrease>

pub fn group_increase(&self) -> Selector<'a, NoticeEventGroupIncrease>

pub fn group_ban(&self) -> Selector<'a, NoticeEventGroupBan>

pub fn friend_add(&self) -> Selector<'a, NoticeEventFriendAdd>

pub fn group_recall(&self) -> Selector<'a, NoticeEventGroupRecall>

pub fn friend_recall(&self) -> Selector<'a, NoticeEventFriendRecall>

pub fn notify(&self) -> Selector<'a, NoticeEventNotify>

impl<'a> Selector<'a, RequestEventFriend>

pub fn filter(&mut self, f: impl FnOnce(&RequestEventFriend) -> bool)

pub fn and_filter(self, f: impl FnOnce(&RequestEventFriend) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&RequestEventFriend) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&RequestEventFriend) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_comment(&mut self, f: impl FnOnce(&str) -> bool)

pub fn and_filter_comment(self, f: impl FnOnce(&str) -> bool) -> Self

pub async fn filter_comment_async(&mut self, f: impl AsyncFnOnce(&str) -> bool)

pub async fn and_filter_comment_async( self, f: impl AsyncFnOnce(&str) -> bool, ) -> Self

pub fn filter_flag(&mut self, f: impl FnOnce(&str) -> bool)

pub fn and_filter_flag(self, f: impl FnOnce(&str) -> bool) -> Self

pub async fn filter_flag_async(&mut self, f: impl AsyncFnOnce(&str) -> bool)

pub async fn and_filter_flag_async( self, f: impl AsyncFnOnce(&str) -> bool, ) -> Self

impl<'a> Selector<'a, RequestEventGroup>

pub fn filter(&mut self, f: impl FnOnce(&RequestEventGroup) -> bool)

pub fn and_filter(self, f: impl FnOnce(&RequestEventGroup) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&RequestEventGroup) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&RequestEventGroup) -> bool, ) -> Self

pub fn filter_sub_type(&mut self, f: impl FnOnce(GroupType) -> bool)

pub fn and_filter_sub_type(self, f: impl FnOnce(GroupType) -> bool) -> Self

pub async fn filter_sub_type_async( &mut self, f: impl AsyncFnOnce(GroupType) -> bool, )

pub async fn and_filter_sub_type_async( self, f: impl AsyncFnOnce(GroupType) -> bool, ) -> Self

pub fn filter_group_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_group_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_group_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_group_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_user_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_user_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_user_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_user_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_comment(&mut self, f: impl FnOnce(&str) -> bool)

pub fn and_filter_comment(self, f: impl FnOnce(&str) -> bool) -> Self

pub async fn filter_comment_async(&mut self, f: impl AsyncFnOnce(&str) -> bool)

pub async fn and_filter_comment_async( self, f: impl AsyncFnOnce(&str) -> bool, ) -> Self

pub fn filter_flag(&mut self, f: impl FnOnce(&str) -> bool)

pub fn and_filter_flag(self, f: impl FnOnce(&str) -> bool) -> Self

pub async fn filter_flag_async(&mut self, f: impl AsyncFnOnce(&str) -> bool)

pub async fn and_filter_flag_async( self, f: impl AsyncFnOnce(&str) -> bool, ) -> Self

pub fn add(&mut self)

pub fn and_add(self) -> Self

pub fn not_add(&mut self)

pub fn and_not_add(self) -> Self

pub fn invite(&mut self)

pub fn and_invite(self) -> Self

pub fn not_invite(&mut self)

pub fn and_not_invite(self) -> Self

impl<'a> Selector<'a, RequestEvent>

pub fn friend(&self) -> Selector<'a, RequestEventFriend>

pub fn group(&self) -> Selector<'a, RequestEventGroup>

impl<'a> Selector<'a, EventMessage>

pub fn message_event_selector(&self) -> Selector<'a, MessageEvent>

pub fn filter(&mut self, f: impl FnOnce(&'a EventMessage) -> bool)

pub fn and_filter(self, f: impl FnOnce(&'a EventMessage) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&'a EventMessage) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&'a EventMessage) -> bool, ) -> Self

pub fn filter_time(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_time(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_time_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_time_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_self_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_self_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_self_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_self_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_message_event(&mut self, f: impl FnOnce(&MessageEvent) -> bool)

pub fn and_filter_message_event( self, f: impl FnOnce(&MessageEvent) -> bool, ) -> Self

pub async fn filter_message_event_async( &mut self, f: impl AsyncFnOnce(&MessageEvent) -> bool, )

pub async fn and_filter_message_event_async( self, f: impl AsyncFnOnce(&MessageEvent) -> bool, ) -> Self

impl<'a> Selector<'a, EventNotice>

pub fn notice_event_selector(&self) -> Selector<'a, NoticeEvent>

pub fn filter(&mut self, f: impl FnOnce(&'a EventNotice) -> bool)

pub fn and_filter(self, f: impl FnOnce(&'a EventNotice) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&'a EventNotice) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&'a EventNotice) -> bool, ) -> Self

pub fn filter_time(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_time(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_time_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_time_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_self_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_self_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_self_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_self_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_notice_event(&mut self, f: impl FnOnce(&NoticeEvent) -> bool)

pub fn and_filter_notice_event( self, f: impl FnOnce(&NoticeEvent) -> bool, ) -> Self

pub async fn filter_notice_event_async( &mut self, f: impl AsyncFnOnce(&NoticeEvent) -> bool, )

pub async fn and_filter_notice_event_async( self, f: impl AsyncFnOnce(&NoticeEvent) -> bool, ) -> Self

impl<'a> Selector<'a, EventRequest>

pub fn request_event_selector(&self) -> Selector<'a, RequestEvent>

pub fn filter(&mut self, f: impl FnOnce(&'a EventRequest) -> bool)

pub fn and_filter(self, f: impl FnOnce(&'a EventRequest) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&'a EventRequest) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&'a EventRequest) -> bool, ) -> Self

pub fn filter_time(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_time(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_time_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_time_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_self_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_self_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_self_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_self_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_request_event(&mut self, f: impl FnOnce(&RequestEvent) -> bool)

pub fn and_filter_request_event( self, f: impl FnOnce(&RequestEvent) -> bool, ) -> Self

pub async fn filter_request_event_async( &mut self, f: impl AsyncFnOnce(&RequestEvent) -> bool, )

pub async fn and_filter_request_event_async( self, f: impl AsyncFnOnce(&RequestEvent) -> bool, ) -> Self

impl<'a> Selector<'a, EventMetaEvent>

pub fn meta_event_selector(&self) -> Selector<'a, MetaEvent>

pub fn filter(&mut self, f: impl FnOnce(&'a EventMetaEvent) -> bool)

pub fn and_filter(self, f: impl FnOnce(&'a EventMetaEvent) -> bool) -> Self

pub async fn filter_async( &mut self, f: impl AsyncFnOnce(&'a EventMetaEvent) -> bool, )

pub async fn and_filter_async( self, f: impl AsyncFnOnce(&'a EventMetaEvent) -> bool, ) -> Self

pub fn filter_time(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_time(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_time_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_time_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_self_id(&mut self, f: impl FnOnce(i64) -> bool)

pub fn and_filter_self_id(self, f: impl FnOnce(i64) -> bool) -> Self

pub async fn filter_self_id_async(&mut self, f: impl AsyncFnOnce(i64) -> bool)

pub async fn and_filter_self_id_async( self, f: impl AsyncFnOnce(i64) -> bool, ) -> Self

pub fn filter_meta_event(&mut self, f: impl FnOnce(&MetaEvent) -> bool)

pub fn and_filter_meta_event(self, f: impl FnOnce(&MetaEvent) -> bool) -> Self

pub async fn filter_meta_event_async( &mut self, f: impl AsyncFnOnce(&MetaEvent) -> bool, )

pub async fn and_filter_meta_event_async( self, f: impl AsyncFnOnce(&MetaEvent) -> bool, ) -> Self

impl<'a> Selector<'a, Event>

pub fn message(&self) -> Selector<'a, EventMessage>

pub fn notice(&self) -> Selector<'a, EventNotice>

pub fn request(&self) -> Selector<'a, EventRequest>

pub fn meta_event(&self) -> Selector<'a, EventMetaEvent>

impl<'a, T> Selector<'a, T>

pub fn map<R>(&self, handler: impl FnOnce(&'a T) -> R) -> Option<R>

pub async fn map_async<R>( &self, handler: impl AsyncFnOnce(&'a T) -> R, ) -> Option<R>

pub fn select(&self) -> Option<&'a T>

pub fn is_matched(&self) -> bool