🥮 mooncakes.io

    mooncoap

    Bounded, deterministic unicast CoAP protocol core for MoonBit

    coap
    rfc7252
    network
    protocol
    iot
    Download zip
    Version
    0.1.1
    License
    Apache-2.0
    Repository
    Last updated
    10 hours ago
    Downloads
    4

    Dependencies

    #MoonCoAP

    Reusable unicast CoAP protocol library implemented in MoonBit.

    The pure core provides RFC7252 message and option codecs, client/server exchange state machines, bounded duplicate suppression, resource routing, conditional representations, response caching and RFC6690 discovery. The native udp package uses the public moonbitlang/async socket API.

    See the repository README for installation, four runnable examples, API usage and reproducible validation. The protocol support matrix defines the implemented subset. DTLS, OSCORE, Observe, Blockwise, multicast, proxying and TCP are outside this release. IPv6 UDP has not been validated.

    Licensed under Apache-2.0. Standards and dependency provenance are documented in THIRD_PARTY.md.

    Action

    source
    pub(all) enum Action {
      SendDatagram(String, Bytes)
      RequestReceived(IncomingRequest)
      ResponseReceived(Int, Message)
      Failed(Int, Failure)
      Cancelled(Int)
    } derive(Eq, 
    Debug    )

    Action::equal

    source
    fn Action::equal(Action, Action) -> Bool

    Action::not_equal

    source
    fn Action::not_equal(x : Action, y : Action) -> Bool

    Action::to_repr

    source

    Allocator

    source
    pub struct Allocator {
      // private fields
    }

    Allocator::active_leases

    source
    fn Allocator::active_leases(self : Allocator) -> Int

    Allocator::allocate_mid

    source
    fn Allocator::allocate_mid(self : Allocator, peer : String, now : Int64) -> Result[Int, Failure]

    Allocator::allocate_token

    source
    fn Allocator::allocate_token(self : Allocator) -> Result[Bytes, Failure]

    Allocator::collect

    source
    fn Allocator::collect(self : Allocator, now : Int64) -> Result[Int, Failure]

    Allocator::is_reserved

    source
    fn Allocator::is_reserved(self : Allocator, peer : String, mid : Int) -> Bool

    Allocator::new

    source
    fn Allocator::new(config : Config) -> Result[Allocator, Failure]

    Allocator::next_expiry

    source
    fn Allocator::next_expiry(self : Allocator) -> Int64?

    Allocator::remaining_capacity

    source
    fn Allocator::remaining_capacity(self : Allocator) -> Int

    Allocator::reserve

    source
    fn Allocator::reserve(self : Allocator, peer : String, mid : Int, now : Int64) -> Result[Unit, Failure]

    CacheKey

    source
    pub(all) struct CacheKey {
      peer : String
      options : Array[CoapOption]
    } derive(Eq, 
    Debug    )

    CacheKey::equal

    source
    fn CacheKey::equal(CacheKey, CacheKey) -> Bool

    CacheKey::not_equal

    source
    fn CacheKey::not_equal(x : CacheKey, y : CacheKey) -> Bool

    CacheKey::to_repr

    source

    CacheLookup

    source
    pub(all) enum CacheLookup {
      Miss
      Fresh(Response)
      Stale(Response, Request)
    } derive(Eq, 
    Debug    )

    CacheLookup::equal

    source
    fn CacheLookup::equal(CacheLookup, CacheLookup) -> Bool

    CacheLookup::not_equal

    source
    fn CacheLookup::not_equal(x : CacheLookup, y : CacheLookup) -> Bool

    CacheLookup::to_repr

    source

    CacheStats

    source
    pub(all) struct CacheStats {
      hits : Int64
      misses : Int64
      stale : Int64
      insertions : Int64
      validations : Int64
      evictions : Int64
      entries : Int
      bytes : Int
    } derive(Eq, 
    Debug    )

    CacheStats::equal

    source
    fn CacheStats::equal(CacheStats, CacheStats) -> Bool

    CacheStats::not_equal

    source
    fn CacheStats::not_equal(x : CacheStats, y : CacheStats) -> Bool

    CacheStats::to_repr

    source

    CoapOption

    source
    pub(all) struct CoapOption {
      number : Int
      value : Bytes
    } derive(Eq, 
    Debug    )

    CoapOption::equal

    source
    fn CoapOption::equal(CoapOption, CoapOption) -> Bool

    CoapOption::not_equal

    source
    fn CoapOption::not_equal(x : CoapOption, y : CoapOption) -> Bool

    CoapOption::to_repr

    source

    CoapUri

    source
    pub(all) struct CoapUri {
      host : String
      port : Int
      path : Array[Bytes]
      query : Array[Bytes]
    } derive(Eq, 
    Debug    )

    CoapUri::equal

    source
    fn CoapUri::equal(CoapUri, CoapUri) -> Bool

    CoapUri::not_equal

    source
    fn CoapUri::not_equal(x : CoapUri, y : CoapUri) -> Bool

    CoapUri::parse

    source
    fn CoapUri::parse(text : String, limits : Limits) -> Result[CoapUri, Failure]

    CoapUri::to_options

    source
    fn CoapUri::to_options(self : CoapUri) -> Array[CoapOption]

    CoapUri::to_repr

    source

    CoapUri::to_string

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

    Code

    source
    pub(all) struct Code {
      value : Int
    } derive(Eq, 
    Debug    )

    Code::class

    source
    fn Code::class(self : Code) -> Int

    Code::description

    source
    fn Code::description(self : Code) -> String

    Code::detail

    source
    fn Code::detail(self : Code) -> Int

    Code::equal

    source
    fn Code::equal(Code, Code) -> Bool

    Code::is_request

    source
    fn Code::is_request(self : Code) -> Bool

    Code::is_response

    source
    fn Code::is_response(self : Code) -> Bool

    Code::is_success

    source
    fn Code::is_success(self : Code) -> Bool

    Code::not_equal

    source
    fn Code::not_equal(x : Code, y : Code) -> Bool

    Code::request

    source
    fn Code::request(verb : Method) -> Code

    Code::response

    source
    fn Code::response(class : Int, detail : Int) -> Result[Code, Failure]

    Code::to_repr

    source

    Code::verb

    source
    fn Code::verb(self : Code) -> Method?

    Config

    source
    pub(all) struct Config {
      limits : Limits
      ack_timeout_ms : Int64
      ack_random_factor_permille : Int
      max_retransmit : Int
      exchange_lifetime_ms : Int64
      non_lifetime_ms : Int64
      response_timeout_ms : Int64
      max_peers : Int
      max_exchanges : Int
      max_dedup : Int
      max_mid_leases : Int
      max_queue : Int
      max_actions : Int
      nstart : Int
      initial_mid : Int
      token_seed : Int64
    } derive(Eq, 
    Debug    )

    Config::default

    source
    fn Config::default() -> Config

    Config::equal

    source
    fn Config::equal(Config, Config) -> Bool

    Config::max_transmit_span

    source
    fn Config::max_transmit_span(self : Config) -> Int64

    Config::not_equal

    source
    fn Config::not_equal(x : Config, y : Config) -> Bool

    Config::to_repr

    source

    Config::validate

    source
    fn Config::validate(self : Config) -> Result[Unit, Failure]

    pub(all) struct CoreLink {
      target : String
      attributes : Array[LinkAttribute]
    } derive(Eq, 
    Debug    )

    CoreLink::attribute

    source
    fn CoreLink::attribute(self : CoreLink, name : String) -> String?

    CoreLink::equal

    source
    fn CoreLink::equal(CoreLink, CoreLink) -> Bool

    CoreLink::not_equal

    source
    fn CoreLink::not_equal(x : CoreLink, y : CoreLink) -> Bool

    CoreLink::to_repr

    source

    CoreLink::validate

    source
    fn CoreLink::validate(self : CoreLink, limits : Limits) -> Result[Unit, Failure]

    Discovery

    source
    pub struct Discovery {
      // private fields
    }

    Discovery::add

    source
    fn Discovery::add(self : Discovery, link : CoreLink) -> Result[Unit, Failure]

    Discovery::handle

    source
    fn Discovery::handle(self : Discovery, message : Message) -> Response

    fn Discovery::links(self : Discovery) -> Array[CoreLink]

    Discovery::new

    source
    fn Discovery::new(limits : Limits) -> Result[Discovery, Failure]

    Discovery::remove

    source
    fn Discovery::remove(self : Discovery, target : String) -> Bool

    Endpoint

    source
    pub struct Endpoint {
      // private fields
    }

    Endpoint::acknowledge

    source
    fn Endpoint::acknowledge(self : Endpoint, id : Int, now : Int64) -> Result[Unit, Failure]

    Endpoint::action_capacity

    source
    fn Endpoint::action_capacity(self : Endpoint) -> Int

    Endpoint::active_for_peer

    source
    fn Endpoint::active_for_peer(self : Endpoint, peer : String) -> Int

    Endpoint::active_peers

    source
    fn Endpoint::active_peers(self : Endpoint) -> Array[String]

    Endpoint::cancel

    source
    fn Endpoint::cancel(self : Endpoint, id : Int, now : Int64) -> Result[Unit, Failure]

    Endpoint::drain

    source
    fn Endpoint::drain(self : Endpoint) -> Array[Action]

    Endpoint::exchange_count

    source
    fn Endpoint::exchange_count(self : Endpoint) -> Int

    Endpoint::exchanges

    source
    fn Endpoint::exchanges(self : Endpoint) -> Array[ExchangeView]

    Endpoint::new

    source
    fn Endpoint::new(config : Config) -> Result[Endpoint, Failure]

    Endpoint::next_deadline

    source
    fn Endpoint::next_deadline(self : Endpoint) -> Int64?

    Endpoint::pending_actions

    source
    fn Endpoint::pending_actions(self : Endpoint) -> Int

    Endpoint::poll

    source
    fn Endpoint::poll(self : Endpoint, now : Int64) -> Result[Unit, Failure]

    Endpoint::queued_count

    source
    fn Endpoint::queued_count(self : Endpoint) -> Int

    Endpoint::receive

    source
    fn Endpoint::receive(self : Endpoint, peer : String, packet : Bytes, now : Int64) -> Result[Unit, Failure]

    Endpoint::receive_request

    source
    fn Endpoint::receive_request(self : Endpoint, peer : String, packet : Bytes, now : Int64) -> Result[Unit, Failure]

    Endpoint::receive_response

    source
    fn Endpoint::receive_response(self : Endpoint, peer : String, packet : Bytes, now : Int64) -> Result[Unit, Failure]

    Endpoint::request

    source
    fn Endpoint::request(self : Endpoint, peer : String, request : Request, now : Int64, random_sample : Int) -> Result[Int, Failure]

    Endpoint::respond

    source
    fn Endpoint::respond(self : Endpoint, id : Int, response : Response, now : Int64, random_sample : Int) -> Result[Unit, Failure]

    Endpoint::response_receipt_count

    source
    fn Endpoint::response_receipt_count(self : Endpoint) -> Int

    Endpoint::serve

    source
    fn Endpoint::serve(self : Endpoint, router : Router, incoming : IncomingRequest, now : Int64) -> Result[Unit, Failure]

    Endpoint::server_records

    source
    fn Endpoint::server_records(self : Endpoint) -> Array[ServerView]

    ExchangePhase

    source
    pub(all) enum ExchangePhase {
      Queued
      Sending
      WaitingResponse
      Finished
    } derive(Eq, 
    Debug    )

    ExchangePhase::equal

    source

    ExchangePhase::not_equal

    source
    fn ExchangePhase::not_equal(x : ExchangePhase, y : ExchangePhase) -> Bool

    ExchangePhase::to_repr

    source

    ExchangeView

    source
    pub(all) struct ExchangeView {
      id : Int
      peer : String
      mid : Int
      token : Bytes
      phase : ExchangePhase
      created_at : Int64
      last_sent_at : Int64
      deadline : Int64
      transmit_deadline : Int64
      next_retry : Int64?
      interval : Int64
      retransmissions : Int
    } derive(Eq, 
    Debug    )

    ExchangeView::equal

    source

    ExchangeView::not_equal

    source
    fn ExchangeView::not_equal(x : ExchangeView, y : ExchangeView) -> Bool

    ExchangeView::to_repr

    source

    Failure

    source
    pub(all) enum Failure {
      Syntax(Int, String)
      Invalid(String)
      Capacity(String)
      Unsupported(String)
      Clock(String)
      NotFound(String)
      Conflict(String)
      Transport(String)
      TimedOut
      ResetByPeer
    } derive(Eq, 
    Debug    )

    Failure::equal

    source
    fn Failure::equal(Failure, Failure) -> Bool

    Failure::not_equal

    source
    fn Failure::not_equal(x : Failure, y : Failure) -> Bool

    Failure::to_repr

    source

    IncomingRequest

    source
    pub(all) struct IncomingRequest {
      id : Int
      peer : String
      message : Message
      received_at : Int64
    } derive(Eq, 
    Debug    )

    IncomingRequest::equal

    source

    IncomingRequest::not_equal

    source
    fn IncomingRequest::not_equal(x : IncomingRequest, y : IncomingRequest) -> Bool

    IncomingRequest::to_repr

    source

    Limits

    source
    pub(all) struct Limits {
      max_datagram : Int
      max_options : Int
      max_option_bytes : Int
      max_payload : Int
      max_uri_bytes : Int
      max_links : Int
      max_link_attributes : Int
    } derive(Eq, 
    Debug    )

    Limits::default

    source
    fn Limits::default() -> Limits

    Limits::equal

    source
    fn Limits::equal(Limits, Limits) -> Bool

    Limits::not_equal

    source
    fn Limits::not_equal(x : Limits, y : Limits) -> Bool

    Limits::to_repr

    source

    Limits::validate

    source
    fn Limits::validate(self : Limits) -> Result[Unit, Failure]

    LinkAttribute

    source
    pub(all) struct LinkAttribute {
      name : String
      value : String?
    } derive(Eq, 
    Debug    )

    LinkAttribute::equal

    source

    LinkAttribute::not_equal

    source
    fn LinkAttribute::not_equal(x : LinkAttribute, y : LinkAttribute) -> Bool

    LinkAttribute::to_repr

    source

    LinkFilter

    source
    pub(all) struct LinkFilter {
      name : String
      value : String
      prefix : Bool
    } derive(Eq, 
    Debug    )

    LinkFilter::equal

    source
    fn LinkFilter::equal(LinkFilter, LinkFilter) -> Bool

    LinkFilter::matches

    source
    fn LinkFilter::matches(self : LinkFilter, link : CoreLink) -> Bool

    LinkFilter::not_equal

    source
    fn LinkFilter::not_equal(x : LinkFilter, y : LinkFilter) -> Bool

    LinkFilter::parse

    source
    fn LinkFilter::parse(query : String) -> Result[LinkFilter, Failure]

    LinkFilter::to_repr

    source

    Message

    source
    pub(all) struct Message {
      msg_type : MessageType
      code : Code
      mid : Int
      token : Bytes
      options : Array[CoapOption]
      payload : Bytes
    } derive(Eq, 
    Debug    )

    Message::copy

    source
    fn Message::copy(self : Message) -> Message

    Message::equal

    source
    fn Message::equal(Message, Message) -> Bool

    Message::first_option

    source
    fn Message::first_option(self : Message, number : Int) -> Bytes?

    Message::new

    source
    fn Message::new(msg_type : MessageType, code : Code, mid : Int) -> Message

    Message::not_equal

    source
    fn Message::not_equal(x : Message, y : Message) -> Bool

    Message::option_values

    source
    fn Message::option_values(self : Message, number : Int) -> Array[Bytes]

    Message::remove_option

    source
    fn Message::remove_option(self : Message, number : Int) -> Unit

    Message::replace_option

    source
    fn Message::replace_option(self : Message, number : Int, value : Bytes) -> Unit

    Message::to_repr

    source

    MessageType

    source
    pub(all) enum MessageType {
      Confirmable
      NonConfirmable
      Acknowledgement
      Reset
    } derive(Eq, 
    Debug    )

    MessageType::equal

    source
    fn MessageType::equal(MessageType, MessageType) -> Bool

    MessageType::not_equal

    source
    fn MessageType::not_equal(x : MessageType, y : MessageType) -> Bool

    MessageType::to_repr

    source

    MessageType::wire

    source
    fn MessageType::wire(self : MessageType) -> Int

    Method

    source
    pub(all) enum Method {
      Get
      Post
      Put
      Delete
    } derive(Eq, 
    Debug    )

    Method::equal

    source
    fn Method::equal(Method, Method) -> Bool

    Method::name

    source
    fn Method::name(self : Method) -> String

    Method::not_equal

    source
    fn Method::not_equal(x : Method, y : Method) -> Bool

    Method::to_repr

    source

    Method::wire

    source
    fn Method::wire(self : Method) -> Int

    OptionKind

    source
    pub(all) enum OptionKind {
      Opaque
      Unsigned
      Text
      Flag
    } derive(Eq, 
    Debug    )

    OptionKind::equal

    source
    fn OptionKind::equal(OptionKind, OptionKind) -> Bool

    OptionKind::not_equal

    source
    fn OptionKind::not_equal(x : OptionKind, y : OptionKind) -> Bool

    OptionKind::to_repr

    source

    OptionSpec

    source
    pub(all) struct OptionSpec {
      number : Int
      name : String
      kind : OptionKind
      min_length : Int
      max_length : Int
      repeatable : Bool
      request_only : Bool
      response_only : Bool
    } derive(Eq, 
    Debug    )

    OptionSpec::equal

    source
    fn OptionSpec::equal(OptionSpec, OptionSpec) -> Bool

    OptionSpec::not_equal

    source
    fn OptionSpec::not_equal(x : OptionSpec, y : OptionSpec) -> Bool

    OptionSpec::to_repr

    source

    Representation

    source
    pub(all) struct Representation {
      payload : Bytes
      content_format : Int
      etag : Bytes
      max_age : Int64
    } derive(Eq, 
    Debug    )

    Representation::equal

    source

    Representation::not_equal

    source
    fn Representation::not_equal(x : Representation, y : Representation) -> Bool

    Representation::response

    source
    fn Representation::response(self : Representation, valid : Bool) -> Response

    Representation::to_repr

    source

    Representation::validate

    source
    fn Representation::validate(self : Representation, limits : Limits) -> Result[Unit, Failure]

    Request

    source
    pub(all) struct Request {
      verb : Method
      options : Array[CoapOption]
      payload : Bytes
      confirmable : Bool
    } derive(Eq, 
    Debug    )

    Request::equal

    source
    fn Request::equal(Request, Request) -> Bool

    Request::from_uri

    source
    fn Request::from_uri(verb : Method, text : String, limits : Limits) -> Result[(CoapUri, Request), Failure]

    Request::new

    source
    fn Request::new(verb : Method) -> Request

    Request::not_equal

    source
    fn Request::not_equal(x : Request, y : Request) -> Bool

    Request::to_repr

    source

    ResourceInfo

    source
    pub(all) struct ResourceInfo {
      path : String
      content_format : Int
      size : Int
      etag : Bytes
      writable : Bool
    } derive(Eq, 
    Debug    )

    ResourceInfo::equal

    source

    ResourceInfo::not_equal

    source
    fn ResourceInfo::not_equal(x : ResourceInfo, y : ResourceInfo) -> Bool

    ResourceInfo::to_repr

    source

    ResourceStore

    source
    pub struct ResourceStore {
      // private fields
    }

    ResourceStore::byte_size

    source
    fn ResourceStore::byte_size(self : ResourceStore) -> Int

    ResourceStore::discovery

    source
    fn ResourceStore::discovery(self : ResourceStore, limits : Limits) -> Result[Discovery, Failure]

    ResourceStore::get

    source
    fn ResourceStore::get(self : ResourceStore, path : String) -> Result[Representation, Failure]

    ResourceStore::handle

    source
    fn ResourceStore::handle(self : ResourceStore, message : Message) -> Response

    ResourceStore::inventory

    source
    fn ResourceStore::inventory(self : ResourceStore) -> Array[ResourceInfo]

    ResourceStore::new

    source
    fn ResourceStore::new(capacity : Int, max_bytes : Int, formats : Array[Int], allow_create : Bool, limits : Limits) -> Result[ResourceStore, Failure]

    ResourceStore::put

    source
    fn ResourceStore::put(self : ResourceStore, path : String, payload : Bytes, format : Int, max_age : Int64, writable : Bool) -> Result[Representation, Failure]

    ResourceStore::remove

    source
    fn ResourceStore::remove(self : ResourceStore, path : String) -> Result[Bool, Failure]

    Response

    source
    pub(all) struct Response {
      code : Code
      options : Array[CoapOption]
      payload : Bytes
    } derive(Eq, 
    Debug    )

    Response::content

    source
    fn Response::content(payload : Bytes) -> Response

    Response::equal

    source
    fn Response::equal(Response, Response) -> Bool

    Response::error

    source
    fn Response::error(code : Int) -> Response

    Response::not_equal

    source
    fn Response::not_equal(x : Response, y : Response) -> Bool

    Response::to_repr

    source

    ResponseCache

    source
    pub struct ResponseCache {
      // private fields
    }

    ResponseCache::clear

    source
    fn ResponseCache::clear(self : ResponseCache) -> Int

    ResponseCache::invalidate

    source
    fn ResponseCache::invalidate(self : ResponseCache, peer : String, path : String) -> Result[Int, Failure]

    ResponseCache::lookup

    source
    fn ResponseCache::lookup(self : ResponseCache, peer : String, request : Request, now : Int64) -> Result[CacheLookup, Failure]

    ResponseCache::new

    source
    fn ResponseCache::new(capacity : Int, max_bytes : Int, limits : Limits) -> Result[ResponseCache, Failure]

    ResponseCache::stats

    source

    ResponseCache::store

    source
    fn ResponseCache::store(self : ResponseCache, peer : String, request : Request, response : Response, now : Int64) -> Result[Unit, Failure]

    ResponseCache::validate

    source
    fn ResponseCache::validate(self : ResponseCache, peer : String, request : Request, response : Response, now : Int64) -> Result[Unit, Failure]

    RouteMatch

    source
    pub(all) struct RouteMatch {
      path : Array[Bytes]
      verb : Method
    } derive(Eq, 
    Debug    )

    RouteMatch::equal

    source
    fn RouteMatch::equal(RouteMatch, RouteMatch) -> Bool

    RouteMatch::not_equal

    source
    fn RouteMatch::not_equal(x : RouteMatch, y : RouteMatch) -> Bool

    RouteMatch::to_repr

    source

    Router

    source
    pub struct Router {
      // private fields
    }

    Router::add

    source
    fn Router::add(self : Router, path : String, verbs : Array[Method], handler : (IncomingRequest) -> Response) -> Result[Unit, Failure]

    Router::dispatch

    source
    fn Router::dispatch(self : Router, incoming : IncomingRequest) -> Response

    Router::new

    source
    fn Router::new(capacity : Int, limits : Limits) -> Result[Router, Failure]

    Router::remove

    source
    fn Router::remove(self : Router, path : String) -> Result[Int, Failure]

    Router::routes

    source
    fn Router::routes(self : Router) -> Array[RouteMatch]

    ServerView

    source
    pub(all) struct ServerView {
      id : Int
      peer : String
      request_mid : Int
      token : Bytes
      expires_at : Int64
      acknowledged : Bool
      answered : Bool
      response_mid : Int?
      response_phase : ExchangePhase?
      response_deadline : Int64?
      last_sent_at : Int64?
      retransmissions : Int
    } derive(Eq, 
    Debug    )

    ServerView::equal

    source
    fn ServerView::equal(ServerView, ServerView) -> Bool

    ServerView::not_equal

    source
    fn ServerView::not_equal(x : ServerView, y : ServerView) -> Bool

    ServerView::to_repr

    source

    bytes_to_hex

    source
    fn bytes_to_hex(bytes : Bytes) -> String

    cache_key

    source
    fn cache_key(peer : String, request : Request, limits : Limits) -> Result[CacheKey, Failure]

    canonical_ipv6

    source
    fn canonical_ipv6(text : String) -> Result[String, Failure]

    canonical_path

    source
    fn canonical_path(parts : Array[Bytes]) -> String

    deadline_after

    source
    fn deadline_after(now : Int64, delay : Int64) -> Result[Int64, Failure]

    decode

    source
    fn decode(bytes : Bytes, limits : Limits) -> Result[Message, Failure]

    decode_utf8

    source
    fn decode_utf8(bytes : Bytes) -> Result[String, Failure]

    empty_control

    source
    fn empty_control(msg_type : MessageType, mid : Int) -> Message

    encode

    source
    fn encode(message : Message, limits : Limits) -> Result[Bytes, Failure]

    encoded_size

    source
    fn encoded_size(message : Message, limits : Limits) -> Result[Int, Failure]

    hex_to_bytes

    source
    fn hex_to_bytes(text : String) -> Result[Bytes, Failure]

    message_uint

    source
    fn message_uint(message : Message, number : Int, default_value : Int64) -> Result[Int64, Failure]

    option_is_cache_key

    source
    fn option_is_cache_key(number : Int) -> Bool

    option_is_critical

    source
    fn option_is_critical(number : Int) -> Bool

    option_is_unsafe

    source
    fn option_is_unsafe(number : Int) -> Bool

    option_text

    source
    fn option_text(number : Int, text : String) -> CoapOption

    option_to_text

    source
    fn option_to_text(option : CoapOption) -> Result[String, Failure]

    option_to_uint

    source
    fn option_to_uint(option : CoapOption) -> Result[Int64, Failure]

    option_uint

    source
    fn option_uint(number : Int, value : Int64) -> Result[CoapOption, Failure]

    parse_ipv4

    source
    fn parse_ipv4(text : String) -> Result[Array[Int], Failure]

    parse_ipv6

    source
    fn parse_ipv6(text : String) -> Result[Array[Int], Failure]

    fn parse_links(payload : Bytes, limits : Limits) -> Result[Array[CoreLink], Failure]

    path_segments

    source
    fn path_segments(message : Message) -> Array[Bytes]

    percent_decode

    source
    fn percent_decode(text : String) -> Result[Bytes, Failure]

    percent_encode

    source
    fn percent_encode(bytes : Bytes) -> String

    preconditions

    source
    fn preconditions(message : Message, current : Representation?) -> Bool

    received_options

    source
    fn received_options(message : Message, supported : Array[Int]) -> Result[Array[CoapOption], Failure]

    request_path

    source
    fn request_path(message : Message) -> Result[String, Failure]

    request_queries

    source
    fn request_queries(message : Message) -> Result[Array[String], Failure]

    resource_path

    source
    fn resource_path(path : String, limits : Limits) -> Result[Array[Bytes], Failure]

    retry_interval

    source
    fn retry_interval(config : Config, random_sample : Int) -> Result[Int64, Failure]

    select_representation

    source
    fn select_representation(message : Message, current : Representation) -> Response

    fn serialize_links(links : Array[CoreLink], limits : Limits) -> Result[Bytes, Failure]

    standard_option

    source
    fn standard_option(number : Int) -> OptionSpec?

    validate_options

    source
    fn validate_options(message : Message, supported_critical : Array[Int]) -> Result[Unit, Failure]

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io