Struct RelayLimitationV2

pub struct RelayLimitationV2 {

    pub max_message_length: Option<usize>,
    pub max_subscriptions: Option<usize>,
    pub max_filters: Option<usize>,
    pub max_limit: Option<usize>,
    pub max_subid_length: Option<usize>,
    pub max_event_tags: Option<usize>,
    pub max_content_length: Option<usize>,
    pub min_pow_difficulty: Option<usize>,
    pub auth_required: Option<bool>,
    pub payment_required: Option<bool>,
    pub restricted_writes: Option<bool>,
    pub created_at_lower_limit: Option<u64>,
    pub created_at_upper_limit: Option<u64>,
}

Relay limitations

Fields

max_message_length: Option<usize>

max message length

max_subscriptions: Option<usize>

max subscriptions

max_filters: Option<usize>

max filters

max_limit: Option<usize>

max limit

max_subid_length: Option<usize>

max subid length

max_event_tags: Option<usize>

max event tags

max_content_length: Option<usize>

max content length

min_pow_difficulty: Option<usize>

min pow difficulty

auth_required: Option<bool>

auth required

payment_required: Option<bool>

payment required

restricted_writes: Option<bool>

restricted writes

created_at_lower_limit: Option<u64>

created at lower limit

created_at_upper_limit: Option<u64>

created at upper limit

Trait Implementations

impl Clone for RelayLimitationV2

fn clone(&self) -> RelayLimitationV2

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RelayLimitationV2

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RelayLimitationV2

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for RelayLimitationV2

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

Formats the value using the given formatter.

impl PartialEq for RelayLimitationV2

fn eq(&self, other: &RelayLimitationV2) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a_, C_: Context> Readable<'a_, C_> for RelayLimitationV2

fn read_from<R_: Reader<'a_, C_>>(_reader_: &mut R_) -> Result<Self, C_::Error>

fn minimum_bytes_needed() -> usize

fn read_from_buffer_with_ctx( context: C, buffer: &'a [u8], ) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_with_ctx( context: C, buffer: &'a [u8], ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_buffer_copying_data_with_ctx( context: C, buffer: &[u8], ) -> Result<Self, <C as Context>::Error>

fn read_with_length_from_buffer_copying_data_with_ctx( context: C, buffer: &[u8], ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_with_length_from_buffer_copying_data_with_ctx_mut( context: &mut C, buffer: &[u8], ) -> (Result<Self, <C as Context>::Error>, usize)

fn read_from_stream_unbuffered_with_ctx<S>( context: C, stream: S, ) -> Result<Self, <C as Context>::Error>

where S: Read,

fn read_from_stream_buffered_with_ctx<S>( context: C, stream: S, ) -> Result<Self, <C as Context>::Error>

where S: Read,

fn read_from_file_with_ctx( context: C, path: impl AsRef<Path>, ) -> Result<Self, <C as Context>::Error>

impl Serialize for RelayLimitationV2

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<C_: Context> Writable<C_> for RelayLimitationV2

fn write_to<T_: ?Sized + Writer<C_>>( &self, _writer_: &mut T_, ) -> Result<(), C_::Error>

fn write_to_buffer_with_ctx( &self, context: C, buffer: &mut [u8], ) -> Result<(), <C as Context>::Error>

fn write_to_buffer_with_ctx_mut( &self, context: &mut C, buffer: &mut [u8], ) -> Result<(), <C as Context>::Error>

fn write_to_vec_with_ctx( &self, context: C, ) -> Result<Vec<u8>, <C as Context>::Error>

fn write_to_vec_with_ctx_mut( &self, context: &mut C, ) -> Result<Vec<u8>, <C as Context>::Error>

fn write_to_stream_with_ctx<S>( &self, context: C, stream: S, ) -> Result<(), <C as Context>::Error>

where S: Write,

fn write_to_file_with_ctx( &self, context: C, path: impl AsRef<Path>, ) -> Result<(), <C as Context>::Error>

fn bytes_needed(&self) -> Result<usize, <C as Context>::Error>

impl Copy for RelayLimitationV2

impl Eq for RelayLimitationV2

impl StructuralPartialEq for RelayLimitationV2