gstreamer-rs/gstreamer-webrtc/src/auto/enums.rs

// This file was generated by gir (https://github.com/gtk-rs/gir @ d1e0127)
// from gir-files (https://github.com/gtk-rs/gir-files @ ???)
// DO NOT EDIT

use ffi;
use glib::translate::*;

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WebRTCDTLSTransportState {
    New,
    Closed,
    Failed,
    Connecting,
    Connected,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for WebRTCDTLSTransportState {
    type GlibType = ffi::GstWebRTCDTLSTransportState;

    fn to_glib(&self) -> ffi::GstWebRTCDTLSTransportState {
        match *self {
            WebRTCDTLSTransportState::New => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_NEW,
            WebRTCDTLSTransportState::Closed => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CLOSED,
            WebRTCDTLSTransportState::Failed => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_FAILED,
            WebRTCDTLSTransportState::Connecting => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTING,
            WebRTCDTLSTransportState::Connected => ffi::GST_WEBRTC_DTLS_TRANSPORT_STATE_CONNECTED,
            WebRTCDTLSTransportState::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstWebRTCDTLSTransportState> for WebRTCDTLSTransportState {
    fn from_glib(value: ffi::GstWebRTCDTLSTransportState) -> Self {
        skip_assert_initialized!();
        match value {
            0 => WebRTCDTLSTransportState::New,
            1 => WebRTCDTLSTransportState::Closed,
            2 => WebRTCDTLSTransportState::Failed,
            3 => WebRTCDTLSTransportState::Connecting,
            4 => WebRTCDTLSTransportState::Connected,
            value => WebRTCDTLSTransportState::__Unknown(value),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WebRTCICEComponent {
    Rtp,
    Rtcp,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for WebRTCICEComponent {
    type GlibType = ffi::GstWebRTCICEComponent;

    fn to_glib(&self) -> ffi::GstWebRTCICEComponent {
        match *self {
            WebRTCICEComponent::Rtp => ffi::GST_WEBRTC_ICE_COMPONENT_RTP,
            WebRTCICEComponent::Rtcp => ffi::GST_WEBRTC_ICE_COMPONENT_RTCP,
            WebRTCICEComponent::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstWebRTCICEComponent> for WebRTCICEComponent {
    fn from_glib(value: ffi::GstWebRTCICEComponent) -> Self {
        skip_assert_initialized!();
        match value {
            0 => WebRTCICEComponent::Rtp,
            1 => WebRTCICEComponent::Rtcp,
            value => WebRTCICEComponent::__Unknown(value),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WebRTCICEConnectionState {
    New,
    Checking,
    Connected,
    Completed,
    Failed,
    Disconnected,
    Closed,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for WebRTCICEConnectionState {
    type GlibType = ffi::GstWebRTCICEConnectionState;

    fn to_glib(&self) -> ffi::GstWebRTCICEConnectionState {
        match *self {
            WebRTCICEConnectionState::New => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_NEW,
            WebRTCICEConnectionState::Checking => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CHECKING,
            WebRTCICEConnectionState::Connected => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CONNECTED,
            WebRTCICEConnectionState::Completed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_COMPLETED,
            WebRTCICEConnectionState::Failed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_FAILED,
            WebRTCICEConnectionState::Disconnected => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_DISCONNECTED,
            WebRTCICEConnectionState::Closed => ffi::GST_WEBRTC_ICE_CONNECTION_STATE_CLOSED,
            WebRTCICEConnectionState::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstWebRTCICEConnectionState> for WebRTCICEConnectionState {
    fn from_glib(value: ffi::GstWebRTCICEConnectionState) -> Self {
        skip_assert_initialized!();
        match value {
            0 => WebRTCICEConnectionState::New,
            1 => WebRTCICEConnectionState::Checking,
            2 => WebRTCICEConnectionState::Connected,
            3 => WebRTCICEConnectionState::Completed,
            4 => WebRTCICEConnectionState::Failed,
            5 => WebRTCICEConnectionState::Disconnected,
            6 => WebRTCICEConnectionState::Closed,
            value => WebRTCICEConnectionState::__Unknown(value),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WebRTCICEGatheringState {
    New,
    Gathering,
    Complete,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for WebRTCICEGatheringState {
    type GlibType = ffi::GstWebRTCICEGatheringState;

    fn to_glib(&self) -> ffi::GstWebRTCICEGatheringState {
        match *self {
            WebRTCICEGatheringState::New => ffi::GST_WEBRTC_ICE_GATHERING_STATE_NEW,
            WebRTCICEGatheringState::Gathering => ffi::GST_WEBRTC_ICE_GATHERING_STATE_GATHERING,
            WebRTCICEGatheringState::Complete => ffi::GST_WEBRTC_ICE_GATHERING_STATE_COMPLETE,
            WebRTCICEGatheringState::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstWebRTCICEGatheringState> for WebRTCICEGatheringState {
    fn from_glib(value: ffi::GstWebRTCICEGatheringState) -> Self {
        skip_assert_initialized!();
        match value {
            0 => WebRTCICEGatheringState::New,
            1 => WebRTCICEGatheringState::Gathering,
            2 => WebRTCICEGatheringState::Complete,
            value => WebRTCICEGatheringState::__Unknown(value),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WebRTCICERole {
    Controlled,
    Controlling,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for WebRTCICERole {
    type GlibType = ffi::GstWebRTCICERole;

    fn to_glib(&self) -> ffi::GstWebRTCICERole {
        match *self {
            WebRTCICERole::Controlled => ffi::GST_WEBRTC_ICE_ROLE_CONTROLLED,
            WebRTCICERole::Controlling => ffi::GST_WEBRTC_ICE_ROLE_CONTROLLING,
            WebRTCICERole::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstWebRTCICERole> for WebRTCICERole {
    fn from_glib(value: ffi::GstWebRTCICERole) -> Self {
        skip_assert_initialized!();
        match value {
            0 => WebRTCICERole::Controlled,
            1 => WebRTCICERole::Controlling,
            value => WebRTCICERole::__Unknown(value),
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
pub enum WebRTCSDPType {
    Offer,
    Pranswer,
    Answer,
    Rollback,
    #[doc(hidden)]
    __Unknown(i32),
}

#[doc(hidden)]
impl ToGlib for WebRTCSDPType {
    type GlibType = ffi::GstWebRTCSDPType;

    fn to_glib(&self) -> ffi::GstWebRTCSDPType {
        match *self {
            WebRTCSDPType::Offer => ffi::GST_WEBRTC_SDP_TYPE_OFFER,
            WebRTCSDPType::Pranswer => ffi::GST_WEBRTC_SDP_TYPE_PRANSWER,
            WebRTCSDPType::Answer => ffi::GST_WEBRTC_SDP_TYPE_ANSWER,
            WebRTCSDPType::Rollback => ffi::GST_WEBRTC_SDP_TYPE_ROLLBACK,
            WebRTCSDPType::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ffi::GstWebRTCSDPType> for WebRTCSDPType {
    fn from_glib(value: ffi::GstWebRTCSDPType) -> Self {
        skip_assert_initialized!();
        match value {
            1 => WebRTCSDPType::Offer,
            2 => WebRTCSDPType::Pranswer,
            3 => WebRTCSDPType::Answer,
            4 => WebRTCSDPType::Rollback,
            value => WebRTCSDPType::__Unknown(value),
        }
    }
}