6ace91a21a
All checks were successful
Create and publish a Docker image 🚀 / build-and-push-image (push) Successful in 1m49s
144 lines
2.7 KiB
Go
144 lines
2.7 KiB
Go
package httpsfv
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
)
|
|
|
|
// Params are an ordered map of key-value pairs that are associated with an item or an inner list.
|
|
//
|
|
// See https://httpwg.org/specs/rfc9651.html#param.
|
|
type Params struct {
|
|
names []string
|
|
values map[string]interface{}
|
|
}
|
|
|
|
// ErrInvalidParameterFormat is returned when the format of a parameter is invalid.
|
|
var ErrInvalidParameterFormat = errors.New("invalid parameter format")
|
|
|
|
// ErrInvalidParameterValue is returned when a parameter key is invalid.
|
|
var ErrInvalidParameterValue = errors.New("invalid parameter value")
|
|
|
|
// ErrMissingParameters is returned when the Params structure is missing from the element.
|
|
var ErrMissingParameters = errors.New("missing parameters")
|
|
|
|
// NewParams creates a new ordered map.
|
|
func NewParams() *Params {
|
|
p := Params{}
|
|
p.names = []string{}
|
|
p.values = map[string]interface{}{}
|
|
|
|
return &p
|
|
}
|
|
|
|
// Get retrieves a parameter.
|
|
func (p *Params) Get(k string) (interface{}, bool) {
|
|
v, ok := p.values[k]
|
|
|
|
return v, ok
|
|
}
|
|
|
|
// Add appends a new parameter to the ordered list.
|
|
// If the key already exists, overwrite its value.
|
|
func (p *Params) Add(k string, v interface{}) {
|
|
assertBareItem(v)
|
|
|
|
if _, exists := p.values[k]; !exists {
|
|
p.names = append(p.names, k)
|
|
}
|
|
|
|
p.values[k] = v
|
|
}
|
|
|
|
// Del removes a parameter from the ordered list.
|
|
func (p *Params) Del(key string) bool {
|
|
if _, ok := p.values[key]; !ok {
|
|
return false
|
|
}
|
|
|
|
for i, k := range p.names {
|
|
if k == key {
|
|
p.names = append(p.names[:i], p.names[i+1:]...)
|
|
|
|
break
|
|
}
|
|
}
|
|
|
|
delete(p.values, key)
|
|
|
|
return true
|
|
}
|
|
|
|
// Names retrieves the list of parameter names in the appropriate order.
|
|
func (p *Params) Names() []string {
|
|
return p.names
|
|
}
|
|
|
|
// marshalSFV serializes as defined in
|
|
// https://httpwg.org/specs/rfc9651.html#ser-params.
|
|
func (p *Params) marshalSFV(b *strings.Builder) error {
|
|
if p == nil {
|
|
return ErrMissingParameters
|
|
}
|
|
for _, k := range p.names {
|
|
if err := b.WriteByte(';'); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := marshalKey(b, k); err != nil {
|
|
return err
|
|
}
|
|
|
|
v := p.values[k]
|
|
if v == true {
|
|
continue
|
|
}
|
|
|
|
if err := b.WriteByte('='); err != nil {
|
|
return err
|
|
}
|
|
|
|
if err := marshalBareItem(b, v); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// parseParams parses as defined in
|
|
// https://httpwg.org/specs/rfc9651.html#parse-param.
|
|
func parseParams(s *scanner) (*Params, error) {
|
|
p := NewParams()
|
|
|
|
for !s.eof() {
|
|
if s.data[s.off] != ';' {
|
|
break
|
|
}
|
|
s.off++
|
|
s.scanWhileSp()
|
|
|
|
k, err := parseKey(s)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var i interface{}
|
|
|
|
if !s.eof() && s.data[s.off] == '=' {
|
|
s.off++
|
|
|
|
i, err = parseBareItem(s)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
i = true
|
|
}
|
|
|
|
p.Add(k, i)
|
|
}
|
|
|
|
return p, nil
|
|
}
|