Struct mysql_common::binlog::events::IncidentEvent

pub struct IncidentEvent<'a> { /* private fields */ }

Used to log an out of the ordinary event that occurred on the master.

It notifies the slave that something happened on the master that might cause data to be in an inconsistent state.

Implementations

impl<'a> IncidentEvent<'a>

pub fn new( incident_type: IncidentType, message: impl Into<Cow<'a, [u8]>>, ) -> Self

pub fn incident_type(&self) -> Result<IncidentType, UnknownIncidentType>

Returns the incident_type value, if it’s valid.

pub fn message_raw(&'a self) -> &'a [u8]

Returns the raw message value.

pub fn message(&'a self) -> Cow<'a, str>

Returns message value as a string (lossy converted).

pub fn with_incident_type(self, incident_type: IncidentType) -> Self

Sets the incident_type value.

pub fn with_message(self, message: impl Into<Cow<'a, [u8]>>) -> Self

Sets the message value.

pub fn into_owned(self) -> IncidentEvent<'static>

Trait Implementations

impl<'a> BinlogEvent<'a> for IncidentEvent<'a>

const EVENT_TYPE: EventType = EventType::INCIDENT_EVENT

An event type, associated with this struct (if any).

impl<'a> BinlogStruct<'a> for IncidentEvent<'a>

fn len(&self, _version: BinlogVersion) -> usize

Returns serialized length of this struct in bytes.

impl<'a> Clone for IncidentEvent<'a>

fn clone(&self) -> IncidentEvent<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for IncidentEvent<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for IncidentEvent<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'de> MyDeserialize<'de> for IncidentEvent<'de>

const SIZE: Option<usize> = None

Size hint of a serialized value (in bytes), if it’s constant.

type Ctx = BinlogCtx<'de>

Some structs defines deserialization in the context of another value.

fn deserialize(_ctx: Self::Ctx, buf: &mut ParseBuf<'de>) -> Result<Self>

Deserializes self from the given buf.

impl MySerialize for IncidentEvent<'_>

fn serialize(&self, buf: &mut Vec<u8>)

Serializes self into the buf.

impl<'a> PartialEq for IncidentEvent<'a>

fn eq(&self, other: &IncidentEvent<'a>) -> 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> Eq for IncidentEvent<'a>

impl<'a> StructuralPartialEq for IncidentEvent<'a>