structs

README

Go Struct Reflect

Provide a common policy to call a handler dynamically by the struct field tag.

Example

See Reflector.

Documentation

Overview

Package structs provides a common policy to call a handler dynamically by the struct field tag.

Index

• Variables
• func Reflect(structValuePtr any) error
• func ReflectContext(ctx, structValuePtr any) error
• func ReflectValue(structValue reflect.Value) error
• func ReflectValueContext(ctx any, structValue reflect.Value) error
• func Register(name string, handler handler.Handler)
• func RegisterRunner(name string, handler handler.Runner)
• func Unregister(name string)
• type Reflector
  • func NewReflector() *Reflector
  • func (r *Reflector) Reflect(structValuePtr any) error
  • func (r *Reflector) ReflectContext(ctx, structValuePtr any) error
  • func (r *Reflector) ReflectValue(value reflect.Value) error
  • func (r *Reflector) ReflectValueContext(ctx any, value reflect.Value) error
  • func (r *Reflector) Register(name string, handler handler.Handler)
  • func (r *Reflector) Unregister(name string)

Examples

• Reflector

Variables

var DefaultReflector = NewReflector()

DefaultReflector is the default global struct field reflector.

Functions

func Reflect

func Reflect(structValuePtr any) error

Reflect is equal to ReflectContext(nil, structValuePtr).

func ReflectContext

func ReflectContext(ctx, structValuePtr any) error

ReflectContext is equal to DefaultReflector.ReflectContext(ctx, structValuePtr).

func ReflectValue

func ReflectValue(structValue reflect.Value) error

ReflectValue is equal to ReflectValueContext(nil, structValue).

func ReflectValueContext

func ReflectValueContext(ctx any, structValue reflect.Value) error

ReflectValueContext is equal to DefaultReflector.ReflectValueContext(ctx, structValue).

func Register

func Register(name string, handler handler.Handler)

Register is equal to DefaultReflector.Register(name, handler).

func RegisterRunner

func RegisterRunner(name string, handler handler.Runner)

RegisterRunner is equal to Register(name, handler).

func Unregister

func Unregister(name string)

Unregister is equal to DefaultReflector.Unregister(name).

Types

type Reflector

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

Reflector is used to reflect the tags of the fields of the struct and call the field handler by the tag name with the tag value.

Example

parseInt := func(s string) (interface{}, error) { return strconv.ParseInt(s, 10, 64) }
compareInt := func(isMin bool) handler.Runner {
	return func(_ interface{}, _, v reflect.Value, t reflect.StructField, a interface{}) error {
		value := v.Interface().(int64)
		if isMin {
			if min := a.(int64); value < min {
				return fmt.Errorf("%s: the value %d is less then %d", t.Name, value, min)
			}
		} else {
			if max := a.(int64); value > max {
				return fmt.Errorf("%s: the value %d is greater then %d", t.Name, value, max)
			}
		}
		return nil
	}
}

sf := NewReflector()
sf.Register("min", handler.New(parseInt, compareInt(true)))
sf.Register("max", handler.New(parseInt, compareInt(false)))
sf.Register("default", handler.SimpleRunner(func(v reflect.Value, s interface{}) error {
	if !v.IsZero() {
		return nil
	}

	i, err := strconv.ParseInt(s.(string), 10, 64)
	if err != nil {
		return fmt.Errorf("invalid default value '%s': %s", s, err)
	}

	v.SetInt(i)
	return nil
}))
sf.Register("datamask", handler.SimpleRunner(func(v reflect.Value, s interface{}) error {
	switch s.(string) {
	case "username":
		name := v.Interface().(string)
		if r, _ := utf8.DecodeRuneInString(name); r != utf8.RuneError {
			v.SetString(string(r) + "**")
		} else {
			return fmt.Errorf("the name is not utf8")
		}

	case "password":
		v.SetString("******")

	default:
		return fmt.Errorf("unknown datamust type '%v'", s)
	}

	return nil
}))

/// Example 1: Check and validate the request arguments
type Request struct {
	Page     int64 `default:"1" min:"1"`
	PageSize int64 `default:"10" min:"10" max:"100"`
}
request := Request{Page: 2}
if err := sf.Reflect(&request); err != nil {
	fmt.Printf("reflect failed: %v\n", err)
} else {
	fmt.Printf("Request.Page: %d\n", request.Page)
	fmt.Printf("Request.PageSize: %d\n", request.PageSize)
}

/// Example 2: Mask the response result data
type Person struct {
	Username string `datamask:"username"`
	Password string `datamask:"password"`

	request Request
	Request Request `reflect:"-"` // Stop to reflect struct recursively.
}
type Response struct {
	Persons []Person
}
response := Response{Persons: []Person{
	{Username: "谢谢", Password: "123456789"},
}}
if err := sf.Reflect(&response); err != nil {
	fmt.Printf("reflect failed: %v\n", err)
} else {
	fmt.Printf("Response.Username: %s\n", response.Persons[0].Username)
	fmt.Printf("Response.Password: %s\n", response.Persons[0].Password)
	fmt.Printf("Response.Request.Page: %d\n", response.Persons[0].Request.Page)
	fmt.Printf("Response.Request.PageSize: %d\n", response.Persons[0].Request.PageSize)
	fmt.Printf("Response.request.Page: %d\n", response.Persons[0].request.Page)
	fmt.Printf("Response.request.PageSize: %d\n", response.Persons[0].request.PageSize)
}

Output:

Request.Page: 2
Request.PageSize: 10
Response.Username: 谢**
Response.Password: ******
Response.Request.Page: 0
Response.Request.PageSize: 0
Response.request.Page: 0
Response.request.PageSize: 0

func NewReflector

func NewReflector() *Reflector

NewReflector returns a new Reflector.

func (*Reflector) Reflect

func (r *Reflector) Reflect(structValuePtr any) error

Reflect is equal to ReflectContext(nil, structValuePtr).

func (*Reflector) ReflectContext

func (r *Reflector) ReflectContext(ctx, structValuePtr any) error

ReflectContext reflects all the fields of the struct.

If the field is a struct or slice/array of structs, and has a tag named "reflect" with the value "-", it stops to reflect the struct field recursively.

func (*Reflector) ReflectValue

func (r *Reflector) ReflectValue(value reflect.Value) error

ReflectValue is equal to ReflectValueContext(nil, value).

func (*Reflector) ReflectValueContext

func (r *Reflector) ReflectValueContext(ctx any, value reflect.Value) error

ReflectValueContext is the same as ReflectContext, but uses reflect.Value instead of a pointer to a struct.

func (*Reflector) Register

func (r *Reflector) Register(name string, handler handler.Handler)

Register registers the field handler with the tag name.

func (*Reflector) Unregister

func (r *Reflector) Unregister(name string)

Unregister unregisters the field handler by the tag name.