79 lines
1.8 KiB
Go
79 lines
1.8 KiB
Go
// Package closeenvelope provides the encoder for the client message CLOSE which
|
|
// is a request to terminate a subscription.
|
|
package closeenvelope
|
|
|
|
import (
|
|
"io"
|
|
|
|
"encoders.orly/envelopes"
|
|
"encoders.orly/text"
|
|
"interfaces.orly/codec"
|
|
"lol.mleku.dev/chk"
|
|
)
|
|
|
|
// L is the label associated with this type of codec.Envelope.
|
|
const L = "CLOSE"
|
|
|
|
// T is a CLOSE envelope, which is a signal from client to relay to stop a
|
|
// specified subscription.
|
|
type T struct {
|
|
ID []byte
|
|
}
|
|
|
|
var _ codec.Envelope = (*T)(nil)
|
|
|
|
// New creates an empty new standard formatted closeenvelope.T.
|
|
func New() *T { return new(T) }
|
|
|
|
// NewFrom creates a new closeenvelope.T populated with subscription ID.
|
|
func NewFrom(id []byte) *T { return &T{ID: id} }
|
|
|
|
// Label returns the label of a closeenvelope.T.
|
|
func (en *T) Label() string { return L }
|
|
|
|
// Write the closeenvelope.T to a provided io.Writer.
|
|
func (en *T) Write(w io.Writer) (err error) {
|
|
_, err = w.Write(en.Marshal(nil))
|
|
return
|
|
}
|
|
|
|
// Marshal a closeenvelope.T envelope in minified JSON, appending to a provided
|
|
// destination slice.
|
|
func (en *T) Marshal(dst []byte) (b []byte) {
|
|
b = dst
|
|
b = envelopes.Marshal(
|
|
b, L,
|
|
func(bst []byte) (o []byte) {
|
|
o = bst
|
|
o = append(o, '"')
|
|
o = append(o, en.ID...)
|
|
o = append(o, '"')
|
|
return
|
|
},
|
|
)
|
|
return
|
|
}
|
|
|
|
// Unmarshal a closeenvelope.T from minified JSON, returning the remainder after
|
|
// the end of the envelope.
|
|
func (en *T) Unmarshal(b []byte) (r []byte, err error) {
|
|
r = b
|
|
if en.ID, r, err = text.UnmarshalQuoted(r); chk.E(err) {
|
|
return
|
|
}
|
|
if r, err = envelopes.SkipToTheEnd(r); chk.E(err) {
|
|
return
|
|
}
|
|
return
|
|
}
|
|
|
|
// Parse reads a CLOSE envelope from minified JSON into a newly allocated
|
|
// closeenvelope.T.
|
|
func Parse(b []byte) (t *T, rem []byte, err error) {
|
|
t = New()
|
|
if rem, err = t.Unmarshal(b); chk.E(err) {
|
|
return
|
|
}
|
|
return
|
|
}
|