Enum InputMessage

Source

pub enum InputMessage {
    Premade {
        msgs: Vec<MixPacket>,
        lane: TransmissionLane,
    },
    Regular {
        recipient: Recipient,
        data: Vec<u8>,
        lane: TransmissionLane,
        max_retransmissions: Option<u32>,
    },
    Anonymous {
        recipient: Recipient,
        data: Vec<u8>,
        reply_surbs: u32,
        lane: TransmissionLane,
        max_retransmissions: Option<u32>,
    },
    Reply {
        recipient_tag: AnonymousSenderTag,
        data: Vec<u8>,
        lane: TransmissionLane,
        max_retransmissions: Option<u32>,
    },
    MessageWrapper {
        message: Box<InputMessage>,
        packet_type: PacketType,
    },
}

Variants§

§

Premade

Fire an already prepared mix packets into the network. No guarantees are made about it. For example no retransmssion will be attempted if it gets dropped.

Fields

§msgs: Vec<MixPacket>

§lane: TransmissionLane

§

Regular

The simplest message variant where no additional information is attached. You’re simply sending your data to specified recipient without any tagging.

Ends up with NymMessage::Plain variant

Fields

§recipient: Recipient

§data: Vec<u8>

§lane: TransmissionLane

§max_retransmissions: Option<u32>

§

Anonymous

Creates a message used for a duplex anonymous communication where the recipient will never learn of our true identity. This is achieved by carefully sending reply_surbs.

Note that if reply_surbs is set to zero then this variant requires the client having sent some reply_surbs in the past (and thus the recipient also knowing our sender tag).

Ends up with NymMessage::Repliable variant

Fields

§recipient: Recipient

§data: Vec<u8>

§reply_surbs: u32

§lane: TransmissionLane

§max_retransmissions: Option<u32>

§

Reply

Attempt to use our internally received and stored ReplySurb to send the message back to specified recipient whilst not knowing its full identity (or even gateway).

Ends up with NymMessage::Reply variant

Fields

§recipient_tag: AnonymousSenderTag

§data: Vec<u8>

§lane: TransmissionLane

§max_retransmissions: Option<u32>

§

MessageWrapper

Fields

§message: Box<InputMessage>

§packet_type: PacketType

Enum InputMessage Copy item path

Variants§

Premade

Fields

Regular

Fields

Anonymous

Fields

Reply

Fields

MessageWrapper

Fields

Implementations§

impl InputMessage

pub fn new_premade( msgs: Vec<MixPacket>, lane: TransmissionLane, packet_type: PacketType, ) -> InputMessage

pub fn new_wrapper( message: InputMessage, packet_type: PacketType, ) -> InputMessage

pub fn new_regular( recipient: Recipient, data: Vec<u8>, lane: TransmissionLane, packet_type: Option<PacketType>, ) -> InputMessage

pub fn new_anonymous( recipient: Recipient, data: Vec<u8>, reply_surbs: u32, lane: TransmissionLane, packet_type: Option<PacketType>, ) -> InputMessage

pub fn new_reply( recipient_tag: AnonymousSenderTag, data: Vec<u8>, lane: TransmissionLane, packet_type: Option<PacketType>, ) -> InputMessage

pub fn lane(&self) -> &TransmissionLane

pub fn set_max_retransmissions( &mut self, max_retransmissions: u32, ) -> &mut InputMessage

pub fn with_max_retransmissions(self, max_retransmissions: u32) -> InputMessage

Trait Implementations§

impl Debug for InputMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Auto Trait Implementations§

impl Freeze for InputMessage

impl RefUnwindSafe for InputMessage

impl Send for InputMessage

impl Sync for InputMessage

impl Unpin for InputMessage

impl UnwindSafe for InputMessage

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<U> As for U

fn as_<T>(self) -> Twhere T: CastFrom<U>,

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> Deprecatable for T

fn deprecate(self) -> Deprecated<Self>where Self: Sized,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<T> OptionalSet for T

fn with_optional<F, T>(self, f: F, val: Option<T>) -> Selfwhere F: Fn(Self, T) -> Self, Self: Sized,

fn with_validated_optional<F, T, V, E>( self, f: F, value: Option<T>, validate: V, ) -> Result<Self, E>where F: Fn(Self, T) -> Self, V: Fn(&T) -> Result<(), E>, Self: Sized,

fn with_optional_env<F, T>(self, f: F, val: Option<T>, env_var: &str) -> Selfwhere F: Fn(Self, T) -> Self, T: FromStr, <T as FromStr>::Err: Debug, Self: Sized,

fn with_optional_custom_env<F, T, G>( self, f: F, val: Option<T>, env_var: &str, parser: G, ) -> Selfwhere F: Fn(Self, T) -> Self, G: Fn(&str) -> T, Self: Sized,

impl<T> Pipe for Twhere T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> Rwhere Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> Pointable for T

const ALIGN: usize

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> PolicyExt for Twhere T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>where T: Policy<B, E>, P: Policy<B, E>,

fn or<P, B, E>(self, other: P) -> Or<T, P>where T: Policy<B, E>, P: Policy<B, E>,

Enum InputMessage

impl<T> Any for T
where T: 'static + ?Sized,

fn as_<T>(self) -> T
where T: CastFrom<U>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn conv<T>(self) -> T
where Self: Into<T>,

fn deprecate(self) -> Deprecated<Self>
where Self: Sized,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

fn with_optional<F, T>(self, f: F, val: Option<T>) -> Self
where F: Fn(Self, T) -> Self, Self: Sized,

fn with_validated_optional<F, T, V, E>( self, f: F, value: Option<T>, validate: V, ) -> Result<Self, E>
where F: Fn(Self, T) -> Self, V: Fn(&T) -> Result<(), E>, Self: Sized,

fn with_optional_env<F, T>(self, f: F, val: Option<T>, env_var: &str) -> Self
where F: Fn(Self, T) -> Self, T: FromStr, <T as FromStr>::Err: Debug, Self: Sized,

fn with_optional_custom_env<F, T, G>( self, f: F, val: Option<T>, env_var: &str, parser: G, ) -> Self
where F: Fn(Self, T) -> Self, G: Fn(&str) -> T, Self: Sized,

impl<T> Pipe for T
where T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> PolicyExt for T
where T: ?Sized,

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,