package schema

Import Path
	github.com/gofiber/fiber/v2/internal/schema (on go.dev)

Dependency Relation
	imports 7 packages, and imported by one package

Involved Source Files

	    cache.go
	    converter.go
	    decoder.go
	  d doc.go
		Package gorilla/schema fills a struct with form values.
		
		The basic usage is really simple. Given this struct:
		
			type Person struct {
				Name  string
				Phone string
			}
		
		...we can fill it passing a map to the Decode() function:
		
			values := map[string][]string{
				"Name":  {"John"},
				"Phone": {"999-999-999"},
			}
			person := new(Person)
			decoder := schema.NewDecoder()
			decoder.Decode(person, values)
		
		This is just a simple example and it doesn't make a lot of sense to create
		the map manually. Typically it will come from a http.Request object and
		will be of type url.Values, http.Request.Form, or http.Request.MultipartForm:
		
			func MyHandler(w http.ResponseWriter, r *http.Request) {
				err := r.ParseForm()
		
				if err != nil {
					// Handle error
				}
		
				decoder := schema.NewDecoder()
				// r.PostForm is a map of our POST form values
				err := decoder.Decode(person, r.PostForm)
		
				if err != nil {
					// Handle error
				}
		
				// Do something with person.Name or person.Phone
			}
		
		Note: it is a good idea to set a Decoder instance as a package global,
		because it caches meta-data about structs, and an instance can be shared safely:
		
			var decoder = schema.NewDecoder()
		
		To define custom names for fields, use a struct tag "schema". To not populate
		certain fields, use a dash for the name and it will be ignored:
		
			type Person struct {
				Name  string `schema:"name"`  // custom name
				Phone string `schema:"phone"` // custom name
				Admin bool   `schema:"-"`     // this field is never set
			}
		
		The supported field types in the destination struct are:
		
		  - bool
		  - float variants (float32, float64)
		  - int variants (int, int8, int16, int32, int64)
		  - string
		  - uint variants (uint, uint8, uint16, uint32, uint64)
		  - struct
		  - a pointer to one of the above types
		  - a slice or a pointer to a slice of one of the above types
		
		Non-supported types are simply ignored, however custom types can be registered
		to be converted.
		
		To fill nested structs, keys must use a dotted notation as the "path" for the
		field. So for example, to fill the struct Person below:
		
			type Phone struct {
				Label  string
				Number string
			}
		
			type Person struct {
				Name  string
				Phone Phone
			}
		
		...the source map must have the keys "Name", "Phone.Label" and "Phone.Number".
		This means that an HTML form to fill a Person struct must look like this:
		
			<form>
				<input type="text" name="Name">
				<input type="text" name="Phone.Label">
				<input type="text" name="Phone.Number">
			</form>
		
		Single values are filled using the first value for a key from the source map.
		Slices are filled using all values for a key from the source map. So to fill
		a Person with multiple Phone values, like:
		
			type Person struct {
				Name   string
				Phones []Phone
			}
		
		...an HTML form that accepts three Phone values would look like this:
		
			<form>
				<input type="text" name="Name">
				<input type="text" name="Phones.0.Label">
				<input type="text" name="Phones.0.Number">
				<input type="text" name="Phones.1.Label">
				<input type="text" name="Phones.1.Number">
				<input type="text" name="Phones.2.Label">
				<input type="text" name="Phones.2.Number">
			</form>
		
		Notice that only for slices of structs the slice index is required.
		This is needed for disambiguation: if the nested struct also had a slice
		field, we could not translate multiple values to it if we did not use an
		index for the parent struct.
		
		There's also the possibility to create a custom type that implements the
		TextUnmarshaler interface, and in this case there's no need to register
		a converter, like:
		
			type Person struct {
			  Emails []Email
			}
		
			type Email struct {
			  *mail.Address
			}
		
			func (e *Email) UnmarshalText(text []byte) (err error) {
				e.Address, err = mail.ParseAddress(string(text))
				return
			}
		
		...an HTML form that accepts three Email values would look like this:
		
			<form>
				<input type="email" name="Emails.0">
				<input type="email" name="Emails.1">
				<input type="email" name="Emails.2">
			</form>

	    encoder.go
Package-Level Type Names (total 7)

	/* sort by: alphabet | popularity */
	 type ConversionError (struct)
		ConversionError stores information about a failed conversion.

		Fields (total 4)
			Err error
				// low-level error (when it exists)

			Index int
				// index for multi-value fields; -1 for single-value fields.

			Key string
				// key from the source map.

			Type reflect.Type
				// expected type of elem

		Methods (only one)
			( ConversionError) Error() string
		Implements (at least one exported)
			 ConversionError : error

	 type Converter (func)

		As Inputs Of (at least one exported)
			func (*Decoder).RegisterConverter(value interface{}, converterFunc Converter)

	 type Decoder (struct)
		Decoder decodes values from a map[string][]string to a struct.

		Methods (total 5)
			(*Decoder) Decode(dst interface{}, src map[string][]string) error
				Decode decodes a map[string][]string to a struct.
				
				The first parameter must be a pointer to a struct.
				
				The second parameter is a map, typically url.Values from an HTTP request.
				Keys are "paths" in dotted notation to the struct fields and nested structs.
				
				See the package documentation for a full explanation of the mechanics.

			(*Decoder) IgnoreUnknownKeys(i bool)
				IgnoreUnknownKeys controls the behaviour when the decoder encounters unknown
				keys in the map.
				If i is true and an unknown field is encountered, it is ignored. This is
				similar to how unknown keys are handled by encoding/json.
				If i is false then Decode will return an error. Note that any valid keys
				will still be decoded in to the target struct.
				
				To preserve backwards compatibility, the default value is false.

			(*Decoder) RegisterConverter(value interface{}, converterFunc Converter)
				RegisterConverter registers a converter function for a custom type.

			(*Decoder) SetAliasTag(tag string)
				SetAliasTag changes the tag used to locate custom field aliases.
				The default tag is "schema".

			(*Decoder) ZeroEmpty(z bool)
				ZeroEmpty controls the behaviour when the decoder encounters empty values
				in a map.
				If z is true and a key in the map has the empty string as a value
				then the corresponding struct field is set to the zero value.
				If z is false then empty strings are ignored.
				
				The default value is false, that is empty values do not change
				the value of the struct field.

		As Outputs Of (at least one exported)
			func NewDecoder() *Decoder

	 type EmptyFieldError (struct)
		EmptyFieldError stores information about an empty required field.

		Fields (only one)
			Key string
				// key from the source map.

		Methods (only one)
			( EmptyFieldError) Error() string
		Implements (at least one exported)
			 EmptyFieldError : error

	 type Encoder (struct)
		Encoder encodes values from a struct into url.Values.

		Methods (total 3)
			(*Encoder) Encode(src interface{}, dst map[string][]string) error
				Encode encodes a struct into map[string][]string.
				
				Intended for use with url.Values.

			(*Encoder) RegisterEncoder(value interface{}, encoder func(reflect.Value) string)
				RegisterEncoder registers a converter for encoding a custom type.

			(*Encoder) SetAliasTag(tag string)
				SetAliasTag changes the tag used to locate custom field aliases.
				The default tag is "schema".

		As Outputs Of (at least one exported)
			func NewEncoder() *Encoder

	 type MultiError (map)
		MultiError stores multiple decoding errors.
		
		Borrowed from the App Engine SDK.

		Methods (only one)
			( MultiError) Error() string
		Implements (at least one exported)
			 MultiError : error

	 type UnknownKeyError (struct)
		UnknownKeyError stores information about an unknown key in the source map.

		Fields (only one)
			Key string
				// key from the source map.

		Methods (only one)
			( UnknownKeyError) Error() string
		Implements (at least one exported)
			 UnknownKeyError : error


Package-Level Functions (total 2)

	 func NewDecoder() *Decoder
		NewDecoder returns a new Decoder.

	 func NewEncoder() *Encoder
		NewEncoder returns a new Encoder with defaults.

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.