README
- ::equalAction::equal
- ::not_equalAction::not_equal
- ::to_reprAction::to_repr
- ::active_leasesAllocator::active_leases
- ::allocate_midAllocator::allocate_mid
- ::allocate_tokenAllocator::allocate_token
- ::collectAllocator::collect
- ::is_reservedAllocator::is_reserved
- ::newAllocator::new
- ::next_expiryAllocator::next_expiry
- ::remaining_capacityAllocator::remaining_capacity
- ::reserveAllocator::reserve
- ::equalCacheKey::equal
- ::not_equalCacheKey::not_equal
- ::to_reprCacheKey::to_repr
- ::equalCacheLookup::equal
- ::not_equalCacheLookup::not_equal
- ::to_reprCacheLookup::to_repr
- ::equalCacheStats::equal
- ::not_equalCacheStats::not_equal
- ::to_reprCacheStats::to_repr
- ::equalCoapOption::equal
- ::not_equalCoapOption::not_equal
- ::to_reprCoapOption::to_repr
- ::equalCoapUri::equal
- ::not_equalCoapUri::not_equal
- ::parseCoapUri::parse
- ::to_optionsCoapUri::to_options
- ::to_reprCoapUri::to_repr
- ::to_stringCoapUri::to_string
- ::classCode::class
- ::descriptionCode::description
- ::detailCode::detail
- ::equalCode::equal
- ::is_requestCode::is_request
- ::is_responseCode::is_response
- ::is_successCode::is_success
- ::not_equalCode::not_equal
- ::requestCode::request
- ::responseCode::response
- ::to_reprCode::to_repr
- ::verbCode::verb
- ::defaultConfig::default
- ::equalConfig::equal
- ::max_transmit_spanConfig::max_transmit_span
- ::not_equalConfig::not_equal
- ::to_reprConfig::to_repr
- ::validateConfig::validate
- ::attributeCoreLink::attribute
- ::equalCoreLink::equal
- ::not_equalCoreLink::not_equal
- ::to_reprCoreLink::to_repr
- ::validateCoreLink::validate
- ::addDiscovery::add
- ::handleDiscovery::handle
- ::linksDiscovery::links
- ::newDiscovery::new
- ::removeDiscovery::remove
- ::acknowledgeEndpoint::acknowledge
- ::action_capacityEndpoint::action_capacity
- ::active_for_peerEndpoint::active_for_peer
- ::active_peersEndpoint::active_peers
- ::cancelEndpoint::cancel
- ::drainEndpoint::drain
- ::exchange_countEndpoint::exchange_count
- ::exchangesEndpoint::exchanges
- ::newEndpoint::new
- ::next_deadlineEndpoint::next_deadline
- ::pending_actionsEndpoint::pending_actions
- ::pollEndpoint::poll
- ::queued_countEndpoint::queued_count
- ::receiveEndpoint::receive
- ::receive_requestEndpoint::receive_request
- ::receive_responseEndpoint::receive_response
- ::requestEndpoint::request
- ::respondEndpoint::respond
- ::response_receipt_countEndpoint::response_receipt_count
- ::serveEndpoint::serve
- ::server_recordsEndpoint::server_records
- ::equalExchangePhase::equal
- ::not_equalExchangePhase::not_equal
- ::to_reprExchangePhase::to_repr
- ::equalExchangeView::equal
- ::not_equalExchangeView::not_equal
- ::to_reprExchangeView::to_repr
- ::equalFailure::equal
- ::not_equalFailure::not_equal
- ::to_reprFailure::to_repr
- ::equalIncomingRequest::equal
- ::not_equalIncomingRequest::not_equal
- ::to_reprIncomingRequest::to_repr
- ::defaultLimits::default
- ::equalLimits::equal
- ::not_equalLimits::not_equal
- ::to_reprLimits::to_repr
- ::validateLimits::validate
- ::equalLinkAttribute::equal
- ::not_equalLinkAttribute::not_equal
- ::to_reprLinkAttribute::to_repr
- ::equalLinkFilter::equal
- ::matchesLinkFilter::matches
- ::not_equalLinkFilter::not_equal
- ::parseLinkFilter::parse
- ::to_reprLinkFilter::to_repr
- ::copyMessage::copy
- ::equalMessage::equal
- ::first_optionMessage::first_option
- ::newMessage::new
- ::not_equalMessage::not_equal
- ::option_valuesMessage::option_values
- ::remove_optionMessage::remove_option
- ::replace_optionMessage::replace_option
- ::to_reprMessage::to_repr
- ::equalMessageType::equal
- ::not_equalMessageType::not_equal
- ::to_reprMessageType::to_repr
- ::wireMessageType::wire
- ::equalMethod::equal
- ::nameMethod::name
- ::not_equalMethod::not_equal
- ::to_reprMethod::to_repr
- ::wireMethod::wire
- ::equalOptionKind::equal
- ::not_equalOptionKind::not_equal
- ::to_reprOptionKind::to_repr
- ::equalOptionSpec::equal
- ::not_equalOptionSpec::not_equal
- ::to_reprOptionSpec::to_repr
- ::equalRepresentation::equal
- ::not_equalRepresentation::not_equal
- ::responseRepresentation::response
- ::to_reprRepresentation::to_repr
- ::validateRepresentation::validate
- ::equalRequest::equal
- ::from_uriRequest::from_uri
- ::newRequest::new
- ::not_equalRequest::not_equal
- ::to_reprRequest::to_repr
- ::equalResourceInfo::equal
- ::not_equalResourceInfo::not_equal
- ::to_reprResourceInfo::to_repr
- ::byte_sizeResourceStore::byte_size
- ::discoveryResourceStore::discovery
- ::getResourceStore::get
- ::handleResourceStore::handle
- ::inventoryResourceStore::inventory
- ::newResourceStore::new
- ::putResourceStore::put
- ::removeResourceStore::remove
- ::contentResponse::content
- ::equalResponse::equal
- ::errorResponse::error
- ::not_equalResponse::not_equal
- ::to_reprResponse::to_repr
- ::clearResponseCache::clear
- ::invalidateResponseCache::invalidate
- ::lookupResponseCache::lookup
- ::newResponseCache::new
- ::statsResponseCache::stats
- ::storeResponseCache::store
- ::validateResponseCache::validate
- ::equalRouteMatch::equal
- ::not_equalRouteMatch::not_equal
- ::to_reprRouteMatch::to_repr
- ::addRouter::add
- ::dispatchRouter::dispatch
- ::newRouter::new
- ::removeRouter::remove
- ::routesRouter::routes
- ::equalServerView::equal
- ::not_equalServerView::not_equal
- ::to_reprServerView::to_repr
V
bytes_to_hex
V
cache_key
V
canonical_ipv6
V
canonical_path
V
deadline_after
V
decode
V
decode_utf8
V
empty_control
V
encode
V
encoded_size
V
hex_to_bytes
V
message_uint
V
option_is_cache_key
V
option_is_critical
V
option_is_unsafe
V
option_text
V
option_to_text
V
option_to_uint
V
option_uint
V
parse_ipv4
V
parse_ipv6
V
parse_links
V
path_segments
V
percent_decode
V
percent_encode
V
preconditions
V
received_options
V
request_path
V
request_queries
V
resource_path
V
retry_interval
V
select_representation
V
serialize_links
V
standard_option
V
validate_options

mooncoap

Bounded, deterministic unicast CoAP protocol core for MoonBit

coap

rfc7252

network

protocol

iot

Download zip

Author

sujy123456

Version

0.1.0

License

Apache-2.0

Repository

github.com/sujy123456/MoonCoAP

Last updated

21 days ago

Downloads

moonbitlang/async0.22.4

#localdev/mooncoap

Action

source

pub(all) enum Action {
  SendDatagram(String, Bytes)
  RequestReceived(IncomingRequest)
  ResponseReceived(Int, Message)
  Failed(Int, Failure)
  Cancelled(Int)
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn Action::to_repr(Action) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn CacheKey::to_repr(CacheKey) -> @moonbitlang/core/debug.Repr
Repr

CacheLookup

source

pub(all) enum CacheLookup {
  Miss
  Fresh(Response)
  Stale(Response, Request)
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn CacheLookup::to_repr(CacheLookup) -> @moonbitlang/core/debug.Repr
Repr

CacheStats

source

pub(all) struct CacheStats {
  hits : Int64
  misses : Int64
  stale : Int64
  insertions : Int64
  validations : Int64
  evictions : Int64
  entries : Int
  bytes : Int
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn CacheStats::to_repr(CacheStats) -> @moonbitlang/core/debug.Repr
Repr

CoapOption

source

pub(all) struct CoapOption {
  number : Int
  value : Bytes
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn CoapOption::to_repr(CoapOption) -> @moonbitlang/core/debug.Repr
Repr

CoapUri

source

pub(all) struct CoapUri {
  host : String
  port : Int
  path : Array[Bytes]
  query : Array[Bytes]
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn CoapUri::to_repr(CoapUri) -> @moonbitlang/core/debug.Repr
Repr

CoapUri::to_string

source

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

Code

source

pub(all) struct Code {
  value : Int
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn Code::to_repr(Code) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn Config::to_repr(Config) -> @moonbitlang/core/debug.Repr
Repr

Config::validate

source

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

CoreLink

source

pub(all) struct CoreLink {
  target : String
  attributes : Array[LinkAttribute]
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn CoreLink::to_repr(CoreLink) -> @moonbitlang/core/debug.Repr
Repr

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

Discovery::links

source

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, @moonbitlang/core/debug.Debug
Debug)

ExchangePhase::equal

source

fn ExchangePhase::equal(ExchangePhase, ExchangePhase) -> Bool

ExchangePhase::not_equal

source

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

ExchangePhase::to_repr

source

fn ExchangePhase::to_repr(ExchangePhase) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
Debug)

ExchangeView::equal

source

fn ExchangeView::equal(ExchangeView, ExchangeView) -> Bool

ExchangeView::not_equal

source

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

ExchangeView::to_repr

source

fn ExchangeView::to_repr(ExchangeView) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn Failure::to_repr(Failure) -> @moonbitlang/core/debug.Repr
Repr

IncomingRequest

source

pub(all) struct IncomingRequest {
  id : Int
  peer : String
  message : Message
  received_at : Int64
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

IncomingRequest::equal

source

fn IncomingRequest::equal(IncomingRequest, IncomingRequest) -> Bool

IncomingRequest::not_equal

source

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

IncomingRequest::to_repr

source

fn IncomingRequest::to_repr(IncomingRequest) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn Limits::to_repr(Limits) -> @moonbitlang/core/debug.Repr
Repr

Limits::validate

source

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

LinkAttribute

source

pub(all) struct LinkAttribute {
  name : String
  value : String?
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

LinkAttribute::equal

source

fn LinkAttribute::equal(LinkAttribute, LinkAttribute) -> Bool

LinkAttribute::not_equal

source

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

LinkAttribute::to_repr

source

fn LinkAttribute::to_repr(LinkAttribute) -> @moonbitlang/core/debug.Repr
Repr

LinkFilter

source

pub(all) struct LinkFilter {
  name : String
  value : String
  prefix : Bool
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn LinkFilter::to_repr(LinkFilter) -> @moonbitlang/core/debug.Repr
Repr

Message

source

pub(all) struct Message {
  msg_type : MessageType
  code : Code
  mid : Int
  token : Bytes
  options : Array[CoapOption]
  payload : Bytes
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn Message::to_repr(Message) -> @moonbitlang/core/debug.Repr
Repr

MessageType

source

pub(all) enum MessageType {
  Confirmable
  NonConfirmable
  Acknowledgement
  Reset
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn MessageType::to_repr(MessageType) -> @moonbitlang/core/debug.Repr
Repr

MessageType::wire

source

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

Method

source

pub(all) enum Method {
  Get
  Post
  Put
  Delete
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn Method::to_repr(Method) -> @moonbitlang/core/debug.Repr
Repr

Method::wire

source

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

OptionKind

source

pub(all) enum OptionKind {
  Opaque
  Unsigned
  Text
  Flag
} derive(Eq, @moonbitlang/core/debug.Debug
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

fn OptionKind::to_repr(OptionKind) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn OptionSpec::to_repr(OptionSpec) -> @moonbitlang/core/debug.Repr
Repr

Representation

source

pub(all) struct Representation {
  payload : Bytes
  content_format : Int
  etag : Bytes
  max_age : Int64
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Representation::equal

source

fn Representation::equal(Representation, Representation) -> Bool

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

fn Representation::to_repr(Representation) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn Request::to_repr(Request) -> @moonbitlang/core/debug.Repr
Repr

ResourceInfo

source

pub(all) struct ResourceInfo {
  path : String
  content_format : Int
  size : Int
  etag : Bytes
  writable : Bool
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

ResourceInfo::equal

source

fn ResourceInfo::equal(ResourceInfo, ResourceInfo) -> Bool

ResourceInfo::not_equal

source

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

ResourceInfo::to_repr

source

fn ResourceInfo::to_repr(ResourceInfo) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn Response::to_repr(Response) -> @moonbitlang/core/debug.Repr
Repr

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

fn ResponseCache::stats(self : ResponseCache) -> CacheStats

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, @moonbitlang/core/debug.Debug
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

fn RouteMatch::to_repr(RouteMatch) -> @moonbitlang/core/debug.Repr
Repr

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, @moonbitlang/core/debug.Debug
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

fn ServerView::to_repr(ServerView) -> @moonbitlang/core/debug.Repr
Repr

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]

parse_links

source

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

serialize_links

source

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

Site source Report issue Packages Build queue Skills Statistics

mooncoap

#localdev/mooncoap

#Action

#Action::equal

#Action::not_equal

#Action::to_repr

#Allocator

#Allocator::active_leases

#Allocator::allocate_mid

#Allocator::allocate_token

#Allocator::collect

#Allocator::is_reserved

#Allocator::new

#Allocator::next_expiry

#Allocator::remaining_capacity

#Allocator::reserve

#CacheKey

#CacheKey::equal

#CacheKey::not_equal

#CacheKey::to_repr

#CacheLookup

#CacheLookup::equal

#CacheLookup::not_equal

#CacheLookup::to_repr

#CacheStats

#CacheStats::equal

#CacheStats::not_equal

#CacheStats::to_repr

#CoapOption

#CoapOption::equal

#CoapOption::not_equal

#CoapOption::to_repr

#CoapUri

#CoapUri::equal

#CoapUri::not_equal

#CoapUri::parse

#CoapUri::to_options

#CoapUri::to_repr

#CoapUri::to_string

#Code

#Code::class

#Code::description

#Code::detail

#Code::equal

#Code::is_request

#Code::is_response

#Code::is_success

#Code::not_equal

#Code::request

#Code::response

#Code::to_repr

#Code::verb

#Config

#Config::default

#Config::equal

#Config::max_transmit_span

#Config::not_equal

#Config::to_repr

#Config::validate

#CoreLink

#CoreLink::attribute

#CoreLink::equal

#CoreLink::not_equal

#CoreLink::to_repr

#CoreLink::validate

#Discovery

#Discovery::add

#Discovery::handle

#Discovery::links

#Discovery::new

#Discovery::remove

#Endpoint

#Endpoint::acknowledge

#Endpoint::action_capacity

#Endpoint::active_for_peer

#Endpoint::active_peers

#Endpoint::cancel

#Endpoint::drain

#Endpoint::exchange_count

#Endpoint::exchanges

Action

Action::equal

Action::not_equal

Action::to_repr

Allocator

Allocator::active_leases

Allocator::allocate_mid

Allocator::allocate_token

Allocator::collect

Allocator::is_reserved

Allocator::new

Allocator::next_expiry

Allocator::remaining_capacity

Allocator::reserve

CacheKey

CacheKey::equal

CacheKey::not_equal

CacheKey::to_repr

CacheLookup

CacheLookup::equal

CacheLookup::not_equal

CacheLookup::to_repr

CacheStats

CacheStats::equal

CacheStats::not_equal

CacheStats::to_repr

CoapOption

CoapOption::equal

CoapOption::not_equal

CoapOption::to_repr

CoapUri

CoapUri::equal

CoapUri::not_equal

CoapUri::parse

CoapUri::to_options

CoapUri::to_repr

CoapUri::to_string

Code

Code::class

Code::description

Code::detail

Code::equal

Code::is_request

Code::is_response

Code::is_success

Code::not_equal

Code::request

Code::response

Code::to_repr

Code::verb

Config

Config::default

Config::equal

Config::max_transmit_span

Config::not_equal

Config::to_repr

Config::validate

CoreLink

CoreLink::attribute

CoreLink::equal

CoreLink::not_equal

CoreLink::to_repr

CoreLink::validate

Discovery

Discovery::add

Discovery::handle

Discovery::links

Discovery::new

Discovery::remove

Endpoint

Endpoint::acknowledge

Endpoint::action_capacity

Endpoint::active_for_peer

Endpoint::active_peers

Endpoint::cancel

Endpoint::drain

Endpoint::exchange_count

Endpoint::exchanges

Endpoint::new

Endpoint::next_deadline