coap

type Client struct {
	// Transport specifies the mechanism by which individual
	// CoAP requests are made.
	// If nil, DefaultTransport is used.
	Transport RoundTripper

	// Timeout specifies a time limit for requests made by this
	// Client. The timeout includes connection time, any
	// redirects, and reading the response body. The timer remains
	// running after Get, Head, Post, or Do return and will
	// interrupt reading of the Response.Body.
	//
	// A Timeout of zero means no timeout.
	//
	// The Client cancels requests to the underlying Transport
	// using the Request.Cancel mechanism. Requests passed
	// to Client.Do may still set Request.Cancel; both will
	// cancel the request.
	//
	// For compatibility, the Client will also use the deprecated
	// CancelRequest method on Transport if found. New
	// RoundTripper implementations should use Request.Cancel
	// instead of implementing CancelRequest.
	Timeout time.Duration

	// CoAP spcifies the constant NSTART (default = 1) to limit
	// the amount of parallel requests. 0 = no limit.
	// The default client has a value of 1 as proposed by the RFC.
	// For an UART connection only 1 parallel request is supported.
	MaxParallelRequests int32
	// contains filtered or unexported fields
}

type Connection interface {
	PacketReader
	PacketWriter
	InteractionStore

	// Starts a loop that reads packets and forwards them to interactions
	Open() error
	Close() error
	Closed() bool

	Name() string
}

type CountingTokenGenerator struct {
	// contains filtered or unexported fields
}

type Interaction struct {

	// CancelObserve will stop the interaction to listen for Notifications
	StopListenForNotifications context.CancelFunc

	// Channel to hand over raw coap messages from notification updates
	// to the underlying transport where they can be converted into response structs
	NotificationCh chan *coapmsg.Message
	// contains filtered or unexported fields
}

type InteractionStore interface {
	FindInteraction(token Token, msgId MessageId) *Interaction
	StartInteraction(conn Connection, msg *coapmsg.Message) *Interaction
	RemoveInteraction(ia *Interaction)
	InteractionCount() int
}

type Interactions struct {
	// contains filtered or unexported fields
}

type MessageId uint16

type NotifyFunc func(ia *Interaction, currResponse *coapmsg.Message)

type PacketReader interface {
	ReadPacket() (p []byte, isPrefix bool, err error)
}

type PacketWriter interface {
	WritePacket(p []byte) (err error)
}

type Parity byte

type RandomTokenGenerator struct {
	// contains filtered or unexported fields
}

type Request struct {
	// Method specifies the HTTP method (GET, POST, PUT, etc.).
	// For client requests an empty string means GET.
	Method string

	// Confirmable CoAP requests will be confirmed by an ACK
	// from the server.
	Confirmable bool

	// URL specifies either the URI being requested (for server
	// requests) or the URL to access (for client requests).
	//
	// For server requests the URL is parsed from the URI
	// supplied in the CoAP message. (See RFC 7252, Section 6)
	//
	// For client requests, the URL's Host specifies the server to
	// connect to.
	URL *url.URL

	// The protocol version for incoming server requests.
	//
	// For client requests these fields are ignored. The CoAP
	// client code always uses CoAP/1.
	// See the docs on Transport for details.
	Proto        string // "CoAP/1"
	ProtoVersion int    // 1 - encoded as 2 bit field in CoAP messages

	// CoAP Options are like HTTP Headers and used in a similar way
	Options coapmsg.CoapOptions

	// Token specifies the Reuquest token that is used to identify the response
	//
	// If the Token is empty it will be issued by the Transport
	// The client can set a specific Token, e.g. to cancel a specific observe request
	Token Token

	// Body is the request's body.
	//
	// For client requests a nil body means the request has no
	// body, such as a GET request. The Client's Transport
	// is responsible for calling the Close method.
	//
	// For server requests the Request Body is always non-nil
	// but will return EOF immediately when no body is present.
	// The Server will close the request body. The Serve****
	// Handler does not need to.
	Body io.ReadCloser

	// Cancel is an optional channel whose closure indicates that the client
	// request should be regarded as canceled. Not all implementations of
	// RoundTripper may support Cancel.
	//
	// For server requests, this field is not applicable.
	//
	// Deprecated: Use the Context and WithContext methods
	// instead. If a Request's Cancel field and context are both
	// set, it is undefined whether Cancel is respected.
	Cancel <-chan struct{}
	// contains filtered or unexported fields
}

type Response struct {
	Status     string // e.g. "2.05 Content"
	StatusCode uint8  // e.g. 69 - which is the int representation of 2.05

	// Body represents the response body.
	//
	// The coap Client and Transport guarantee that Body is always
	// non-nil, even on responses without a body or responses with
	// a zero-length body. It is the caller's responsibility to
	// close Body. The default CoAP client's Transport does not
	// attempt to reuse connections ("keep-alive") unless the Body
	// is read to completion and is closed.
	//
	// The Body is automatically dechunked if the server replied
	// with a "chunked" Transfer-Encoding.
	// See: RFC 7959 (Block-wise transfers in CoAP)
	Body io.ReadCloser

	Options coapmsg.CoapOptions

	// Request is the request that was sent to obtain this Response.
	// Request's Body is nil (having already been consumed).
	// This is only populated for Client requests.
	Request *Request
	// contains filtered or unexported fields
}

type RoundTripper interface {
	// RoundTrip executes a single CoAP transaction, returning
	// a Response for the provided Request.
	//
	// RoundTrip should not attempt to interpret the response. In
	// particular, RoundTrip must return err == nil if it obtained
	// a response, regardless of the response's CoAP status code.
	// A non-nil err should be reserved for failure to obtain a
	// response. Similarly, RoundTrip should not attempt to
	// handle higher-level protocol details such as redirects,
	// authentication, or cookies.
	//
	// RoundTrip should not modify the request, except for
	// consuming and closing the Request's Body.
	//
	// RoundTrip must always close the body, including on errors,
	// but depending on the implementation may do so in a separate
	// goroutine even after RoundTrip returns. This means that
	// callers wanting to reuse the body for subsequent requests
	// must arrange to wait for the Close call before doing so.
	//
	// The Request's URL and Header fields must be initialized.
	RoundTrip(*Request) (*Response, error)
}

type SafeBuffer struct {
	// contains filtered or unexported fields
}

type SerialConnecter interface {
	Connect(host string) (Connection, error)
}

type SerialMode struct {
	BaudRate int      // The serial port bitrate (aka Baudrate)
	DataBits int      // Size of the character (must be 5, 6, 7 or 8)
	Parity   Parity   // Parity (see Parity type for more info)
	StopBits StopBits // Stop bits (see StopBits type for more info)
}

type SerialPort interface {
	io.Reader
	io.Writer
	io.Closer
	ResetInputBuffer() error
	ResetOutputBuffer() error
	// SetDTR sets the modem status bit DataTerminalReady
	SetDTR(dtr bool) error
	// SetRTS sets the modem status bit RequestToSend
	SetRTS(rts bool) error
}

type SlipMuxReader struct {
	// contains filtered or unexported fields
}

type SlipMuxWriter struct {
	// contains filtered or unexported fields
}

type StopBits byte

type Token []byte

type TokenGenerator interface {
	NextToken() []byte
}

type Transport struct {
	TransUart RoundTripper
}

type TransportUart struct {
	TokenGenerator TokenGenerator
	Connecter      SerialConnecter
	// contains filtered or unexported fields
}

type UartConnector struct {
	UartParams
	// contains filtered or unexported fields
}

type UartParams struct {
	// UART parameters. In future we might want to configure this per port.
	Baud       int      // BaudRate
	Parity     Parity   // Parity is the bit to use and defaults to ParityNone (no parity bit).
	StopBits   StopBits // Number of stop bits to use. Default is 1 (1 stop bit).
	DataBits   int
	InitialDTR bool
	InitialRTS bool
}