podman
602 строки · 16.4 Кб
1package toml2)17// Unmarshaler is the interface implemented by objects that can unmarshal a19// TOML description of themselves.20type Unmarshaler interface {21UnmarshalTOML(interface{}) error22}23// Unmarshal decodes the contents of data in TOML format into a pointer v.25//26// See [Decoder] for a description of the decoding process.27func Unmarshal(data []byte, v interface{}) error {28_, err := NewDecoder(bytes.NewReader(data)).Decode(v)29return err30}31// Decode the TOML data in to the pointer v.33//34// See [Decoder] for a description of the decoding process.35func Decode(data string, v interface{}) (MetaData, error) {36return NewDecoder(strings.NewReader(data)).Decode(v)37}38// DecodeFile reads the contents of a file and decodes it with [Decode].40func DecodeFile(path string, v interface{}) (MetaData, error) {41fp, err := os.Open(path)42if err != nil {43return MetaData{}, err44}45defer fp.Close()46return NewDecoder(fp).Decode(v)47}48// Primitive is a TOML value that hasn't been decoded into a Go value.50//51// This type can be used for any value, which will cause decoding to be delayed.52// You can use [PrimitiveDecode] to "manually" decode these values.53//54// NOTE: The underlying representation of a `Primitive` value is subject to55// change. Do not rely on it.56//57// NOTE: Primitive values are still parsed, so using them will only avoid the58// overhead of reflection. They can be useful when you don't know the exact type59// of TOML data until runtime.60type Primitive struct {61undecoded interface{}62context Key63}64// The significand precision for float32 and float64 is 24 and 53 bits; this is66// the range a natural number can be stored in a float without loss of data.67const (68maxSafeFloat32Int = 16777215 // 2^24-169maxSafeFloat64Int = int64(9007199254740991) // 2^53-170)71// Decoder decodes TOML data.73//74// TOML tables correspond to Go structs or maps; they can be used75// interchangeably, but structs offer better type safety.76//77// TOML table arrays correspond to either a slice of structs or a slice of maps.78//79// TOML datetimes correspond to [time.Time]. Local datetimes are parsed in the80// local timezone.81//82// [time.Duration] types are treated as nanoseconds if the TOML value is an83// integer, or they're parsed with time.ParseDuration() if they're strings.84//85// All other TOML types (float, string, int, bool and array) correspond to the86// obvious Go types.87//88// An exception to the above rules is if a type implements the TextUnmarshaler89// interface, in which case any primitive TOML value (floats, strings, integers,90// booleans, datetimes) will be converted to a []byte and given to the value's91// UnmarshalText method. See the Unmarshaler example for a demonstration with92// email addresses.93//94// # Key mapping95//96// TOML keys can map to either keys in a Go map or field names in a Go struct.97// The special `toml` struct tag can be used to map TOML keys to struct fields98// that don't match the key name exactly (see the example). A case insensitive99// match to struct names will be tried if an exact match can't be found.100//101// The mapping between TOML values and Go values is loose. That is, there may102// exist TOML values that cannot be placed into your representation, and there103// may be parts of your representation that do not correspond to TOML values.104// This loose mapping can be made stricter by using the IsDefined and/or105// Undecoded methods on the MetaData returned.106//107// This decoder does not handle cyclic types. Decode will not terminate if a108// cyclic type is passed.109type Decoder struct {110r io.Reader111}112// NewDecoder creates a new Decoder.114func NewDecoder(r io.Reader) *Decoder {115return &Decoder{r: r}116}117)123// Decode TOML data in to the pointer `v`.125func (dec *Decoder) Decode(v interface{}) (MetaData, error) {126rv := reflect.ValueOf(v)127if rv.Kind() != reflect.Ptr {128s := "%q"129if reflect.TypeOf(v) == nil {130s = "%v"131}132}171// PrimitiveDecode is just like the other Decode* functions, except it decodes a173// TOML value that has already been parsed. Valid primitive values can *only* be174// obtained from values filled by the decoder functions, including this method.175// (i.e., v may contain more [Primitive] values.)176//177// Meta data for primitive values is included in the meta data returned by the178// Decode* functions with one exception: keys returned by the Undecoded method179// will only reflect keys that were decoded. Namely, any keys hidden behind a180// Primitive will be considered undecoded. Executing this method will update the181// undecoded keys in the meta data. (See the example.)182func (md *MetaData) PrimitiveDecode(primValue Primitive, v interface{}) error {183md.context = primValue.context184defer func() { md.context = nil }()185return md.unify(primValue.undecoded, rvalue(v))186}187// unify performs a sort of type unification based on the structure of `rv`,189// which is the client representation.190//191// Any type mismatch produces an error. Finding a type that we don't know192// how to handle produces an unsupported type error.193func (md *MetaData) unify(data interface{}, rv reflect.Value) error {194// Special case. Look for a `Primitive` value.195// TODO: #76 would make this superfluous after implemented.196if rv.Type() == primitiveType {197// Save the undecoded data and the key context into the primitive198// value.199context := make(Key, len(md.context))200copy(context, md.context)201rv.Set(reflect.ValueOf(Primitive{202undecoded: data,203context: context,204}))205return nil206}207}260}306}349}363}379}390}410}440}483}491}496}530}534}545}557// rvalue returns a reflect.Value of `v`. All pointers are resolved.559func rvalue(v interface{}) reflect.Value {560return indirect(reflect.ValueOf(v))561}562// indirect returns the value pointed to by a pointer.564//565// Pointers are followed until the value is not a pointer. New values are566// allocated for each nil pointer.567//568// An exception to this rule is if the value satisfies an interface of interest569// to us (like encoding.TextUnmarshaler).570func indirect(v reflect.Value) reflect.Value {571if v.Kind() != reflect.Ptr {572if v.CanSet() {573pv := v.Addr()574pvi := pv.Interface()575if _, ok := pvi.(encoding.TextUnmarshaler); ok {576return pv577}578if _, ok := pvi.(Unmarshaler); ok {579return pv580}581}582return v583}584if v.IsNil() {585v.Set(reflect.New(v.Type().Elem()))586}587return indirect(reflect.Indirect(v))588}589}603