reflectils

package module
v1.0.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 19, 2021 License: MIT Imports: 3 Imported by: 0

README

REFLECTILS Go Reference

Golang Reflect Utilities

Documentation

Index

Examples

Constants

This section is empty.

Variables

View Source 
var ErrStopIteration = errors.New("ErrStopIteration")

ErrStopIteration tells IterValue to break iteration.

Functions

func AnyKind added in v1.0.2 

func AnyKind(v Kinder, k ...reflect.Kind) bool

AnyKind returns true if v.Kind matchs k.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

func main() {
	v := reflect.ValueOf("reflectils")
	fmt.Println(reflectils.AnyKind(v, reflect.String))
	fmt.Println(reflectils.AnyKind(v, reflect.Uint))
}

Output:

true
false

func FindTypeOfStructFieldsByKind 

func FindTypeOfStructFieldsByKind(v reflect.Type, k ...reflect.Kind) (r map[int]reflect.Type)

FindTypeOfStructFieldsByKind returns a field type of v if matches by k.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

type ExampleStruct struct {
	A string
	B uint
	C int
}

func main() {
	v := reflect.TypeOf((*ExampleStruct)(nil)).Elem()
	fmt.Println(reflectils.FindTypeOfStructFieldsByKind(v, reflect.String, reflect.Int))
}

Output:

map[0:string 2:int]

func FindValueOfStructFieldsByKind 

func FindValueOfStructFieldsByKind(v reflect.Value, k ...reflect.Kind) (r map[int]reflect.Value)

FindValueOfStructFieldsByKind returns a field value of v if field type matches by k.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

type ExampleStruct struct {
	A string
	B uint
	C int
}

func main() {
	v := reflect.ValueOf(ExampleStruct{
		A: "reflectils",
		B: 123,
		C: 456,
	})
	fmt.Println(reflectils.FindValueOfStructFieldsByKind(v, reflect.String, reflect.Int))
}

Output:

map[0:reflectils 2:<int Value>]

func GetTypeByKind added in v1.0.2 

func GetTypeByKind(v reflect.Type, k reflect.Kind) (reflect.Type, bool)

GetTypeByKind returns v if v matchs k. will use v.Elem if v is ptr.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

func main() {
	v := reflect.TypeOf(&struct{ Name string }{"reflectils"})
	res, ok := reflectils.GetTypeByKind(v, reflect.Struct)
	fmt.Println(v)
	fmt.Println(ok, res)
}

Output:

*struct { Name string }
true struct { Name string }
Example (WithInvalidValue) 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

func main() {
	res, ok := reflectils.GetTypeByKind(reflect.TypeOf("reflectils"), reflect.Bool)
	fmt.Println(ok, res)
}

Output:

false <nil>

func GetValueByKind added in v1.0.2 

func GetValueByKind(v reflect.Value, k reflect.Kind) (reflect.Value, bool)

GetValueByKind returns v if v type matchs k. will use v.Elem if v type is ptr.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

func main() {
	v := reflect.ValueOf(&struct{ Name string }{"reflectils"})
	res, ok := reflectils.GetValueByKind(v, reflect.Struct)
	fmt.Println(v)
	fmt.Println(ok, res)
}

Output:

&{reflectils}
true {reflectils}
Example (WithInvalidValue) 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

func main() {
	res, ok := reflectils.GetValueByKind(reflect.ValueOf("reflectils"), reflect.Bool)
	fmt.Println(ok, res)
}

Output:

false <invalid reflect.Value>

func IterValue added in v1.0.4 

func IterValue(v []reflect.Value, f func(i int, e reflect.Value) (err error)) (err error)

IterValue iters v until f returns an error. Return err will be nil if f returns ErrStopIteration.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

func main() {
	v := reflectils.NewSliceOfValue("reflectils", reflect.ValueOf(1), 2.3)
	_ = reflectils.IterValue(v, func(i int, e reflect.Value) (err error) {
		if e.Kind() == reflect.Int {
			err = reflectils.ErrStopIteration
		}
		fmt.Println(i, e)
		return
	})
}

Output:

0 reflectils
1 1

func MapStructFields added in v1.0.3 

func MapStructFields(v reflect.Type, f func(i int, v reflect.StructField) error) (err error)

MapStructFields calls f with v fields. will break iteration if f returns an error.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

type ExampleStruct struct {
	A string
	B uint
	C int
}

func main() {
	v := reflect.TypeOf((*ExampleStruct)(nil)).Elem()
	_ = reflectils.MapStructFields(v, func(i int, v reflect.StructField) error {
		fmt.Println(i, v.Name, v.Type)
		return nil
	})
}

Output:

0 A string
1 B uint
2 C int
Example (WithErrorHandling) 
package main

import (
	"errors"
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

type ExampleStruct struct {
	A string
	B uint
	C int
}

func main() {
	v := reflect.TypeOf((*ExampleStruct)(nil)).Elem()
	err := reflectils.MapStructFields(v, func(i int, v reflect.StructField) (err error) {
		switch v.Type.Kind() {
		default:
			return errors.New("unexpected")
		case reflect.String, reflect.Uint:
		}
		fmt.Println(i, v.Name, v.Type)
		return nil
	})
	fmt.Println(err)
}

Output:

0 A string
1 B uint
unexpected

func MapTypeOfStructFields 

func MapTypeOfStructFields(v reflect.Type, f func(i int, v reflect.Type) error) (err error)

MapTypeOfStructFields calls f with v fields type. will break iteration if f returns an error.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

type ExampleStruct struct {
	A string
	B uint
	C int
}

func main() {
	v := reflect.TypeOf((*ExampleStruct)(nil)).Elem()
	_ = reflectils.MapTypeOfStructFields(v, func(i int, v reflect.Type) error {
		fmt.Println(i, v)
		return nil
	})
}

Output:

0 string
1 uint
2 int
Example (WithErrorHandling) 
package main

import (
	"errors"
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

type ExampleStruct struct {
	A string
	B uint
	C int
}

func main() {
	v := reflect.TypeOf((*ExampleStruct)(nil)).Elem()
	err := reflectils.MapTypeOfStructFields(v, func(i int, v reflect.Type) error {
		switch v.Kind() {
		default:
			return errors.New("unexpected")
		case reflect.String, reflect.Uint:
		}
		fmt.Println(i, v)
		return nil
	})
	fmt.Println(err)
}

Output:

0 string
1 uint
unexpected

func MapValueOfStructFields 

func MapValueOfStructFields(v reflect.Value, f func(i int, v reflect.Value) error) (err error)

MapValueOfStructFields calls f with v fields. will break iteration if f returns an error.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

type ExampleStruct struct {
	A string
	B uint
	C int
}

func main() {
	v := reflect.ValueOf(ExampleStruct{
		A: "reflectils",
		B: 123,
		C: 456,
	})
	_ = reflectils.MapValueOfStructFields(v, func(i int, v reflect.Value) error {
		fmt.Println(i, v)
		return nil
	})
}

Output:

0 reflectils
1 123
2 456
Example (WithErrorHandling) 
package main

import (
	"errors"
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

type ExampleStruct struct {
	A string
	B uint
	C int
}

func main() {
	v := reflect.ValueOf(ExampleStruct{
		A: "reflectils",
		B: 123,
		C: 456,
	})
	err := reflectils.MapValueOfStructFields(v, func(i int, v reflect.Value) error {
		switch v.Kind() {
		default:
			return errors.New("unexpected")
		case reflect.String, reflect.Uint:
		}
		fmt.Println(i, v)
		return nil
	})
	fmt.Println(err)
}

Output:

0 reflectils
1 123
unexpected

func NewSliceOfValue added in v1.0.4 

func NewSliceOfValue(v ...interface{}) (r []reflect.Value)

NewSliceOfValue returns new slice of reflect.Value from v.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

func main() {
	v := reflectils.NewSliceOfValue("reflectils", reflect.ValueOf(1), 2.3)
	_ = reflectils.IterValue(v, func(i int, e reflect.Value) (err error) {
		fmt.Println(e)
		return nil
	})
}

Output:

reflectils
1
2.3

func StringFromBytes added in v1.0.3 

func StringFromBytes(b []byte) string

StringFromBytes returns string from b without memory allocation.

Example 
package main

import (
	"fmt"

	"github.com/acarsync/reflectils"
)

func main() {
	fmt.Println(reflectils.StringFromBytes([]byte("Hello World")))
}

Output:

Hello World

func StringToBytes added in v1.0.3 

func StringToBytes(s string) []byte

StringToBytes returns bytes from s without memory allocation.

Example 
package main

import (
	"fmt"

	"github.com/acarsync/reflectils"
)

func main() {
	fmt.Println(reflectils.StringFromBytes(reflectils.StringToBytes("Hello World")))
}

Output:

Hello World

Types

type EmptyStruct 

type EmptyStruct struct{}

EmptyStruct a struct that contains nothing.

type Kinder added in v1.0.2 

type Kinder interface {
	Kind() reflect.Kind
}

Kinder a interface that wraps Kind method.

type MapOfKind 

type MapOfKind map[reflect.Kind]EmptyStruct

MapOfKind a map that contains reflect.Kind.

Example 
package main

import (
	"fmt"
	"reflect"

	"github.com/acarsync/reflectils"
)

func main() {
	m := reflectils.NewMapOfKind(reflect.String, reflect.Int)
	fmt.Println(m.Has(reflect.String))
	fmt.Println(m.Has(reflect.Uint))
	fmt.Println(m.Has(reflect.Int))
}

Output:

true
false
true

func NewMapOfKind 

func NewMapOfKind(k ...reflect.Kind) (v MapOfKind)

NewMapOfKind returns new MapOfKind.

func (MapOfKind) Has 

func (m MapOfKind) Has(k reflect.Kind) bool

Has returns true if k is in m.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.