cbor

type Base64String ¶

type Base64String string

Base64String is a base64 with padding encoded data. CBOR tags that has tag number 34 is converted to this type. The decoder and the encoder validate that it is a valid base64-encoded string. See RFC 8949 Section 3.4.5.3.

type Base64URLString ¶

type Base64URLString string

Base64URLString is a base64url with no padding encoded string. CBOR tags that has tag number 33 is converted to this type. The decoder and the encoder validate that it is a valid base64url-encoded string. See RFC 8949 Section 3.4.5.3.

type CBORMarshaler ¶

type CBORMarshaler interface {
	// MarshalCBOR returns the CBOR encoding of the receiver.
	MarshalCBOR() ([]byte, error)
}

type Decoder ¶

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

A Decoder reads and decodes CBOR values from an input stream.

func NewDecoder(r io.Reader) *Decoder

func (dec *Decoder) Decode(v any) error

func (dec *Decoder) UseAnyKey()

func (dec *Decoder) UseInteger()

type EncodedData ¶

type EncodedData []byte

EncodedData is a CBOR encoded data. CBOR tags that has tag number 24 is converted to this type. See RFC 8949 Section 3.4.5.1.

type Encoder ¶

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

An Encoder writes CBOR to an output stream.

func NewEncoder(w io.Writer) *Encoder

func (enc *Encoder) Encode(v any) error

type ExpectedBase16 ¶

type ExpectedBase16 struct {
	Content any
}

ExpectedBase16 is data expected to be encoded as base16-encoding (as known as hex-encoding). CBOR tags that has tag number 23 is converted to this type. When encoded to JSON, []byte in Content is converted to a base16-encoded string. See RFC 8949 Section 3.4.5.2.

data, _ := json.Marshal(cbor.ExpectedBase16{
	Content: []byte("🍣"),
})
fmt.Println(string(data))

Output:

"f09f8da3"

func (e ExpectedBase16) MarshalJSON() ([]byte, error)

type ExpectedBase64 ¶

type ExpectedBase64 struct {
	Content any
}

ExpectedBase64 is data expected to be encoded as base64-encoding. CBOR tags that has tag number 22 is converted to this type. When encoded to JSON, []byte in Content is converted to a base64-encoded string. See RFC 8949 Section 3.4.5.2.

data, _ := json.Marshal(cbor.ExpectedBase64{
	Content: []byte("🍣"),
})
fmt.Println(string(data))

Output:

"8J+Now=="

func (e ExpectedBase64) MarshalJSON() ([]byte, error)

type ExpectedBase64URL ¶

type ExpectedBase64URL struct {
	Content any
}

ExpectedBase64URL is data expected to be encoded as base64url-encoding. CBOR tags that has tag number 21 is converted to this type. When encoded to JSON, []byte in Content is converted to a base64url-encoded string. See RFC 8949 Section 3.4.5.2.

data, _ := json.Marshal(cbor.ExpectedBase64URL{
	Content: []byte("🍣"),
})
fmt.Println(string(data))

Output:

"8J-Now"

func (e ExpectedBase64URL) MarshalJSON() ([]byte, error)

type Integer ¶

type Integer struct {
	// Sign is true if the integer is negative.
	Sign bool

	// Value presents the value of the integer.
	// If the integer is positive, the value is Value itself.
	// If the integer is negative, the value is -Value-1.
	Value uint64
}

Integer is a CBOR integer type.

func (i Integer) BigInt() *big.Int

func (i Integer) Int64() (int64, error)

func (i Integer) MarshalJSON() ([]byte, error)

func (i Integer) String() string

func (i Integer) Uint64() (uint64, error)

func (i *Integer) UnmarshalJSON(b []byte) error

type InvalidUnmarshalError ¶

type InvalidUnmarshalError struct {
	Type reflect.Type
}

An InvalidUnmarshalError describes an invalid argument passed to Unmarshal. (The argument to Unmarshal must be a non-nil pointer.)

func (e *InvalidUnmarshalError) Error() string

type Options ¶

type Options struct {
	// UseInteger will decode CBOR integers as Integer instead of Go int64.
	UseInteger bool

	// UseAnyKey will decode CBOR map keys as Go map[any]any instead of map[string]any.
	UseAnyKey bool
}

func (o Options) Unmarshal(data []byte, v any) error

type RawMessage ¶

type RawMessage []byte

RawMessage is a raw encoded CBOR value. It implements Marshaler and Unmarshaler and can be used to delay CBOR decoding or precompute a CBOR encoding. nil RawMessage encodes as the CBOR undefined value.

func DecodeEDN(data []byte) (RawMessage, error)

func (m RawMessage) EncodeEDN() ([]byte, error)

func (m RawMessage) MarshalCBOR() ([]byte, error)

func (m *RawMessage) UnmarshalCBOR(data []byte) error

type RawTag ¶

type RawTag struct {
	Number  TagNumber
	Content RawMessage
}

func (tag RawTag) Decode(v any, opts Options) error

type SemanticError ¶

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

SemanticError is a description of a CBOR semantic error.

func (e *SemanticError) Error() string

func (e *SemanticError) Unwrap() error

type Simple ¶

type Simple byte

Simple is a CBOR simple type.

type SyntaxError ¶

type SyntaxError struct {
	Offset int64 // error occurred after reading Offset bytes
	// contains filtered or unexported fields
}

A SyntaxError is a description of a CBOR syntax error. Unmarshal will return a SyntaxError if the CBOR can't be parsed.

func (e *SyntaxError) Error() string

type Tag ¶

type Tag struct {
	Number  TagNumber
	Content any
}

Tag is a CBOR tag.

func (tag Tag) Decode(v any, opts Options) error

type TagNumber ¶

type TagNumber uint64

TagNumber is a CBOR tag number type.

type UnmarshalTypeError ¶

type UnmarshalTypeError struct {
	Value  string       // description of CBOR value - "bool", "array", "number -5"
	Type   reflect.Type // type of Go value it could not be assigned to
	Offset int64        // error occurred after reading Offset bytes
	Struct string       // name of the struct type containing the field
	Field  string       // the full path from root node to the field
}

An UnmarshalTypeError describes a CBOR value that was not appropriate for a value of a specific Go type.

func (e *UnmarshalTypeError) Error() string

type Unmarshaler ¶

type Unmarshaler interface {
	UnmarshalCBOR([]byte) error
}

Unmarshaler is the interface implemented by types that can unmarshal a CBOR description of themselves. The input can be assumed to be a valid encoding of a CBOR value. UnmarshalCBOR must copy the CBOR data if it wishes to retain the data after returning.

type UnsupportedTypeError ¶

type UnsupportedTypeError struct {
	Type reflect.Type
}

An UnsupportedTypeError is returned by Marshal when attempting to encode an unsupported value type.

func (e *UnsupportedTypeError) Error() string

type UnsupportedValueError ¶

type UnsupportedValueError struct {
	Value reflect.Value
	Str   string
}

An UnsupportedValueError is returned by Marshal when attempting to encode an unsupported value.

func (e *UnsupportedValueError) Error() string