Sign in

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

    MdnsError

    pub(all) suberror MdnsError {
    InvalidName(String)
    InvalidPacket(String)
    QueryTimedOut
    NameConflict(String)
    UnsupportedMode
    Time(
    TimeError
    )
    } derive(Eq,
    Debug
    )

    MdnsEvent

    pub(all) enum MdnsEvent {
    Resolved(QueryId, Resolution)
    TimedOut(QueryId)
    Cancelled(QueryId)
    } derive(Eq,
    Debug
    )

    Mode

    pub(all) enum Mode {
    QueryOnly
    QueryAndGather
    } derive(Eq,
    Debug
    )

    OutboundQuery

    pub struct OutboundQuery {
    query_id : QueryId
    destination :
    SocketAddress

    payload : Bytes
    } derive(Eq,
    Debug
    )

    OutboundQuery::payload

    fn OutboundQuery::payload(self : OutboundQuery) -> Bytes

    OutboundQuery::query_id

    fn OutboundQuery::query_id(self : OutboundQuery) -> QueryId

    PendingQuery

    type PendingQuery

    Query

    pub(all) struct Query {
    name : String
    now :
    Instant

    } derive(Eq,
    Debug
    )

    QueryId

    pub(all) struct QueryId(UInt64) derive(Eq, Hash,
    Debug
    )

    Resolution

    Resolution::expires_at

    Resolution::name

    fn Resolution::name(self : Resolution) -> String

    Resolver

    Resolver::answer_query

    fn Resolver::answer_query(self : Resolver, payload : Bytes, ttl_seconds? : UInt) -> Bytes? raise MdnsError

    Resolver::cached

    fn Resolver::cached(self : Resolver, name : String, now :
    Instant
    ) -> Resolution? raise MdnsError

    Resolver::cancel

    fn Resolver::cancel(self : Resolver, query_id : QueryId) -> Unit

    Resolver::handle_response

    fn Resolver::handle_response(self : Resolver, now :
    Instant
    , payload : Bytes) -> Unit raise MdnsError

    Resolver::handle_timeout

    fn Resolver::handle_timeout(self : Resolver, now :
    Instant
    ) -> Unit raise MdnsError

    Resolver::is_pending

    fn Resolver::is_pending(self : Resolver, query_id : QueryId) -> Bool

    Resolver::mode

    fn Resolver::mode(self : Resolver) -> Mode

    Resolver::pending_count

    fn Resolver::pending_count(self : Resolver) -> Int

    Resolver::poll_event

    fn Resolver::poll_event(self : Resolver) -> MdnsEvent?

    Resolver::poll_output

    fn Resolver::poll_output(self : Resolver) -> OutboundQuery?

    Resolver::poll_timeout

    Resolver::query

    fn Resolver::query(self : Resolver, name : String, now :
    Instant
    ) -> QueryId raise MdnsError

    Resolver::register

    fn Resolver::register(self : Resolver, name : String, addresses : Array[
    IpAddress
    ]) -> Unit raise MdnsError

    Resolver::registered

    Resolver::unregister

    fn Resolver::unregister(self : Resolver, name : String) -> Unit raise MdnsError

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io