🥮 mooncakes.io
    Sign in

    moonbit-community/rtc/ice does not have a README file

    IceError

    source
    pub(all) suberror IceError {
      InvalidCandidate(String)
      InvalidCredentials
      InvalidState(String)
      RoleConflict
      ChecklistFailed
      Time(
    TimeError    )
      Stun(
    StunError    )
      Turn(
    TurnError    )
      Mdns(
    MdnsError    )
    } derive(Eq, 
    Debug    )

    CandidateAddress

    source
    pub(all) enum CandidateAddress {
      IpAddress(
    IpAddress    )
      MdnsName(String)
    } derive(Eq, 
    Debug    )

    CandidateAddress::parse

    source
    fn CandidateAddress::parse(value : String) -> CandidateAddress raise IceError

    CandidateAddress::to_string

    source
    fn CandidateAddress::to_string(self : CandidateAddress) -> String

    CandidatePair

    source
    pub struct CandidatePair {
      local_candidate : IceCandidate
      remote_candidate : IceCandidate
      priority : UInt64
      state : CandidatePairState
      nominated : Bool
    } derive(Eq, 
    Debug    )

    CandidatePair::is_nominated

    source
    fn CandidatePair::is_nominated(self : CandidatePair) -> Bool

    CandidatePair::local_candidate

    source
    fn CandidatePair::local_candidate(self : CandidatePair) -> IceCandidate

    CandidatePair::priority

    source
    fn CandidatePair::priority(self : CandidatePair) -> UInt64

    CandidatePair::remote_candidate

    source
    fn CandidatePair::remote_candidate(self : CandidatePair) -> IceCandidate

    CandidatePair::state

    source

    CandidatePairState

    source
    pub(all) enum CandidatePairState {
      PairWaiting
      PairInProgress
      PairSucceeded
      PairFailed
    } derive(Eq, 
    Debug    )

    CandidateType

    source
    pub(all) enum CandidateType {
      Host
      ServerReflexive
      PeerReflexive
      Relay
    } derive(Eq, 
    Debug    )

    CandidateType::preference

    source
    fn CandidateType::preference(self : CandidateType) -> UInt16

    CandidateType::to_string

    source
    fn CandidateType::to_string(self : CandidateType) -> String

    IceAgent

    source
    pub struct IceAgent {
      local_credentials : IceCredentials
      remote_credentials : IceCredentials?
      role : IceRole
      tie_breaker : UInt64
      local_candidates : Array[IceCandidate]
      remote_candidates : Array[IceCandidate]
      pairs : Array[CandidatePair]
      transactions : Map[
    TransactionId    , (Int, Bytes, 
    TransportContext    , Int, Int64, 
    Instant    )]
      outputs : 
    Queue    [
    OutboundDatagram    ]
      events : 
    Queue    [IceEvent]
      state : IceConnectionState
      selected_pair_index : Int?
      next_check : 
    Instant    ?
      check_interval : 
    Duration
      initial_rto : 
    Duration
      reliable_timeout : 
    Duration
      max_retransmissions : Int
      disconnected_timeout : 
    Duration
      failed_timeout : 
    Duration
      keepalive_interval : 
    Duration
      next_keepalive : 
    Instant    ?
      disconnected_deadline : 
    Instant    ?
      failed_deadline : 
    Instant    ?
    }

    IceAgent::add_local_candidate

    source
    fn IceAgent::add_local_candidate(self : IceAgent, candidate : IceCandidate, now? : 
    Instant    ) -> Unit raise IceError

    IceAgent::add_remote_candidate

    source
    fn IceAgent::add_remote_candidate(self : IceAgent, candidate : IceCandidate, now? : 
    Instant    ) -> Unit raise IceError

    IceAgent::candidate_pairs

    source
    fn IceAgent::candidate_pairs(self : IceAgent) -> Array[CandidatePair]

    IceAgent::close

    source
    fn IceAgent::close(self : IceAgent) -> Unit

    IceAgent::handle_datagram

    source

    IceAgent::handle_timeout

    source
    fn IceAgent::handle_timeout(self : IceAgent, now : 
    Instant    ) -> Unit raise IceError

    IceAgent::local_candidates

    source
    fn IceAgent::local_candidates(self : IceAgent) -> Array[IceCandidate]

    IceAgent::local_credentials

    source
    fn IceAgent::local_credentials(self : IceAgent) -> IceCredentials

    IceAgent::new

    source
    fn IceAgent::new(local_credentials~ : IceCredentials, role~ : IceRole, tie_breaker~ : UInt64, check_interval? : 
    Duration    , initial_rto? : 
    Duration    , reliable_timeout? : 
    Duration    , max_retransmissions? : Int, disconnected_timeout? : 
    Duration    , failed_timeout? : 
    Duration    , keepalive_interval? : 
    Duration    ) -> IceAgent raise IceError

    IceAgent::poll_datagram

    source

    IceAgent::poll_event

    source
    fn IceAgent::poll_event(self : IceAgent) -> IceEvent?

    IceAgent::poll_timeout

    source

    IceAgent::remote_candidates

    source
    fn IceAgent::remote_candidates(self : IceAgent) -> Array[IceCandidate]

    IceAgent::remote_credentials

    source
    fn IceAgent::remote_credentials(self : IceAgent) -> IceCredentials?

    IceAgent::role

    source
    fn IceAgent::role(self : IceAgent) -> IceRole

    IceAgent::selected_pair

    source
    fn IceAgent::selected_pair(self : IceAgent) -> CandidatePair?

    IceAgent::send

    source
    fn IceAgent::send(self : IceAgent, payload : Bytes) -> Unit raise IceError

    IceAgent::set_remote_credentials

    source
    fn IceAgent::set_remote_credentials(self : IceAgent, credentials : IceCredentials) -> Unit raise IceError

    IceAgent::start

    source

    IceAgent::state

    source
    fn IceAgent::state(self : IceAgent) -> IceConnectionState

    IceCandidate

    source
    pub struct IceCandidate {
      foundation : String
      component : UInt16
      protocol : 
    TransportProtocol
      priority : UInt
      address : CandidateAddress
      port : UInt16
      candidate_type : CandidateType
      related_address : CandidateAddress?
      related_port : UInt16?
      tcp_type : TcpCandidateType?
      extensions : Array[(String, String)]
    } derive(Eq, 
    Debug    )

    IceCandidate::address

    source

    IceCandidate::base_socket_address

    source

    IceCandidate::candidate_type

    source
    fn IceCandidate::candidate_type(self : IceCandidate) -> CandidateType

    IceCandidate::component

    source
    fn IceCandidate::component(self : IceCandidate) -> UInt16

    IceCandidate::extensions

    source
    fn IceCandidate::extensions(self : IceCandidate) -> Array[(String, String)]

    IceCandidate::foundation

    source
    fn IceCandidate::foundation(self : IceCandidate) -> String

    IceCandidate::host

    source
    fn IceCandidate::host(foundation~ : String, address : 
    SocketAddress    , local_preference? : UInt16) -> IceCandidate raise IceError

    IceCandidate::marshal

    source
    fn IceCandidate::marshal(self : IceCandidate) -> String

    IceCandidate::new

    source
    fn IceCandidate::new(foundation~ : String, component~ : UInt16, protocol~ : 
    TransportProtocol    , priority~ : UInt, address~ : CandidateAddress, port~ : UInt16, candidate_type~ : CandidateType, related_address? : CandidateAddress, related_port? : UInt16, tcp_type? : TcpCandidateType, extensions? : Array[(String, String)]) -> IceCandidate raise IceError

    IceCandidate::parse

    source
    fn IceCandidate::parse(value : String) -> IceCandidate raise IceError

    IceCandidate::port

    source
    fn IceCandidate::port(self : IceCandidate) -> UInt16

    IceCandidate::priority

    source
    fn IceCandidate::priority(self : IceCandidate) -> UInt

    IceCandidate::priority_value

    source
    fn IceCandidate::priority_value(candidate_type~ : CandidateType, local_preference~ : UInt16, component~ : UInt16) -> UInt raise IceError

    IceCandidate::protocol

    source

    IceCandidate::related_address

    source
    fn IceCandidate::related_address(self : IceCandidate) -> CandidateAddress?

    IceCandidate::related_port

    source
    fn IceCandidate::related_port(self : IceCandidate) -> UInt16?

    IceCandidate::resolve_mdns

    source

    IceCandidate::socket_address

    source

    IceCandidate::tcp_host

    source
    fn IceCandidate::tcp_host(foundation~ : String, address : 
    SocketAddress    , tcp_type~ : TcpCandidateType, local_preference? : UInt16) -> IceCandidate raise IceError

    IceCandidate::tcp_type

    source
    fn IceCandidate::tcp_type(self : IceCandidate) -> TcpCandidateType?

    IceCandidate::to_sdp_attribute

    source
    fn IceCandidate::to_sdp_attribute(self : IceCandidate) -> String

    IceCandidate::with_mdns_name

    source
    fn IceCandidate::with_mdns_name(self : IceCandidate, name : String) -> IceCandidate raise IceError

    IceConnectionState

    source
    pub(all) enum IceConnectionState {
      New
      Checking
      Connected
      Completed
      Disconnected
      Failed
      Closed
    } derive(Eq, 
    Debug    )

    IceCredentials

    source
    pub struct IceCredentials {
      username_fragment : String
      password : String
    } derive(Eq, 
    Debug    )

    IceCredentials::new

    source
    fn IceCredentials::new(username_fragment~ : String, password~ : String) -> IceCredentials raise IceError

    IceCredentials::password

    source
    fn IceCredentials::password(self : IceCredentials) -> String

    IceCredentials::username_fragment

    source
    fn IceCredentials::username_fragment(self : IceCredentials) -> String

    IceEvent

    source
    pub(all) enum IceEvent {
      ConnectionStateChanged(IceConnectionState)
      RoleChanged(IceRole)
      SelectedPair(CandidatePair)
      ApplicationDatagram(
    InboundDatagram    )
    } derive(Eq, 
    Debug    )

    IceGatheringState

    source
    pub(all) enum IceGatheringState {
      New
      Gathering
      Complete
    } derive(Eq, 
    Debug    )

    IceRole

    source
    pub(all) enum IceRole {
      Controlling
      Controlled
    } derive(Eq, 
    Debug    )

    IceTransportPolicy

    source
    pub(all) enum IceTransportPolicy {
      All
      Relay
    } derive(Eq, 
    Debug    )

    SrflxEvent

    source
    pub(all) enum SrflxEvent {
      ServerReflexiveCandidate(IceCandidate)
      SrflxStateChanged(SrflxGatheringState)
    } derive(Eq, 
    Debug    )

    SrflxGatherer

    source

    SrflxGatherer::close

    source
    fn SrflxGatherer::close(self : SrflxGatherer) -> Unit

    SrflxGatherer::handle_datagram

    source

    SrflxGatherer::handle_timeout

    source

    SrflxGatherer::handles_context

    source

    SrflxGatherer::new

    source

    SrflxGatherer::poll_datagram

    source

    SrflxGatherer::poll_event

    source
    fn SrflxGatherer::poll_event(self : SrflxGatherer) -> SrflxEvent?

    SrflxGatherer::poll_timeout

    source

    SrflxGatherer::start

    source

    SrflxGatherer::state

    source

    SrflxGatheringState

    source
    pub(all) enum SrflxGatheringState {
      SrflxNew
      SrflxGathering
      SrflxComplete
      SrflxFailed
      SrflxClosed
    } derive(Eq, 
    Debug    )

    TcpCandidateType

    source
    pub(all) enum TcpCandidateType {
      Active
      Passive
      SimultaneousOpen
    } derive(Eq, 
    Debug    )

    TcpCandidateType::to_string

    source
    fn TcpCandidateType::to_string(self : TcpCandidateType) -> String

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io