value.go•3.76 kB
// Copyright (C) 2016 Kohei YOSHIDA. All rights reserved.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of The BSD 3-Clause License
// that can be found in the LICENSE file.
package uritemplate
import "strings"
// A varname containing pct-encoded characters is not the same variable as
// a varname with those same characters decoded.
//
// -- https://tools.ietf.org/html/rfc6570#section-2.3
type Values map[string]Value
func (v Values) Set(name string, value Value) {
v[name] = value
}
func (v Values) Get(name string) Value {
if v == nil {
return Value{}
}
return v[name]
}
type ValueType uint8
const (
ValueTypeString = iota
ValueTypeList
ValueTypeKV
valueTypeLast
)
var valueTypeNames = []string{
"String",
"List",
"KV",
}
func (vt ValueType) String() string {
if vt < valueTypeLast {
return valueTypeNames[vt]
}
return ""
}
type Value struct {
T ValueType
V []string
}
func (v Value) String() string {
if v.Valid() && v.T == ValueTypeString {
return v.V[0]
}
return ""
}
func (v Value) List() []string {
if v.Valid() && v.T == ValueTypeList {
return v.V
}
return nil
}
func (v Value) KV() []string {
if v.Valid() && v.T == ValueTypeKV {
return v.V
}
return nil
}
func (v Value) Valid() bool {
switch v.T {
default:
return false
case ValueTypeString:
return len(v.V) > 0
case ValueTypeList:
return len(v.V) > 0
case ValueTypeKV:
return len(v.V) > 0 && len(v.V)%2 == 0
}
}
func (v Value) expand(w *strings.Builder, spec varspec, exp *expression) error {
switch v.T {
case ValueTypeString:
val := v.V[0]
var maxlen int
if max := len(val); spec.maxlen < 1 || spec.maxlen > max {
maxlen = max
} else {
maxlen = spec.maxlen
}
if exp.named {
w.WriteString(spec.name)
if val == "" {
w.WriteString(exp.ifemp)
return nil
}
w.WriteByte('=')
}
return exp.escape(w, val[:maxlen])
case ValueTypeList:
var sep string
if spec.explode {
sep = exp.sep
} else {
sep = ","
}
var pre string
var preifemp string
if spec.explode && exp.named {
pre = spec.name + "="
preifemp = spec.name + exp.ifemp
}
if !spec.explode && exp.named {
w.WriteString(spec.name)
w.WriteByte('=')
}
for i := range v.V {
val := v.V[i]
if i > 0 {
w.WriteString(sep)
}
if val == "" {
w.WriteString(preifemp)
continue
}
w.WriteString(pre)
if err := exp.escape(w, val); err != nil {
return err
}
}
case ValueTypeKV:
var sep string
var kvsep string
if spec.explode {
sep = exp.sep
kvsep = "="
} else {
sep = ","
kvsep = ","
}
var ifemp string
var kescape escapeFunc
if spec.explode && exp.named {
ifemp = exp.ifemp
kescape = escapeLiteral
} else {
ifemp = ","
kescape = exp.escape
}
if !spec.explode && exp.named {
w.WriteString(spec.name)
w.WriteByte('=')
}
for i := 0; i < len(v.V); i += 2 {
if i > 0 {
w.WriteString(sep)
}
if err := kescape(w, v.V[i]); err != nil {
return err
}
if v.V[i+1] == "" {
w.WriteString(ifemp)
continue
}
w.WriteString(kvsep)
if err := exp.escape(w, v.V[i+1]); err != nil {
return err
}
}
}
return nil
}
// String returns Value that represents string.
func String(v string) Value {
return Value{
T: ValueTypeString,
V: []string{v},
}
}
// List returns Value that represents list.
func List(v ...string) Value {
return Value{
T: ValueTypeList,
V: v,
}
}
// KV returns Value that represents associative list.
// KV panics if len(kv) is not even.
func KV(kv ...string) Value {
if len(kv)%2 != 0 {
panic("uritemplate.go: count of the kv must be even number")
}
return Value{
T: ValueTypeKV,
V: kv,
}
}