SkipEntry can be returned from walk functions to skip walking the value of this field. This is only valid in the following functions:
var SkipEntry = errors.New("skip this entry")
func Walk(data, walker interface{}) (err error)
Walk takes an arbitrary value and an interface and traverses the value, calling callbacks on the interface if they are supported. The interface should implement one or more of the walker interfaces in this package, such as PrimitiveWalker, StructWalker, etc.
ArrayWalker implementations are able to handle array elements found within complex structures.
type ArrayWalker interface {
Array(reflect.Value) error
ArrayElem(int, reflect.Value) error
}
EnterExitWalker implementations are notified before and after they walk deeper into complex structures (into struct fields, into slice elements, etc.)
type EnterExitWalker interface {
Enter(Location) error
Exit(Location) error
}
InterfaceWalker implementations are able to handle interface values as they are encountered during the walk.
type InterfaceWalker interface {
Interface(reflect.Value) error
}
type Location uint
const (
None Location = iota
Map
MapKey
MapValue
Slice
SliceElem
Array
ArrayElem
Struct
StructField
WalkLoc
)
func (i Location) String() string
MapWalker implementations are able to handle individual elements found within a map structure.
type MapWalker interface {
Map(m reflect.Value) error
MapElem(m, k, v reflect.Value) error
}
PointerValueWalker implementations are notified with the value of a particular pointer when a pointer is walked. Pointer is called right before PointerEnter.
type PointerValueWalker interface {
Pointer(reflect.Value) error
}
PointerWalker implementations are notified when the value they're walking is a pointer or not. Pointer is called for _every_ value whether it is a pointer or not.
type PointerWalker interface {
PointerEnter(bool) error
PointerExit(bool) error
}
PrimitiveWalker implementations are able to handle primitive values within complex structures. Primitive values are numbers, strings, booleans, funcs, chans.
These primitive values are often members of more complex structures (slices, maps, etc.) that are walkable by other interfaces.
type PrimitiveWalker interface {
Primitive(reflect.Value) error
}
SliceWalker implementations are able to handle slice elements found within complex structures.
type SliceWalker interface {
Slice(reflect.Value) error
SliceElem(int, reflect.Value) error
}
StructWalker is an interface that has methods that are called for structs when a Walk is done.
type StructWalker interface {
Struct(reflect.Value) error
StructField(reflect.StructField, reflect.Value) error
}