[![Go Version][gover-img]][gover] [![GoDoc][doc-img]][doc] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov] [![GoReport][rpt-img]][rpt]

# Fast deep-copy library for Go

## Functionalities

- True deep copy
- Very fast (see [benchmarks](#benchmarks) section)
- Ability to copy almost all Go types (number, string, bool, function, slice, map, struct)
- Ability to copy data between convertible types (for example: copy from `int` to `float`)
- Ability to copy between `pointers` and `values` (for example: copy from `*int` to `int`)
- Ability to copy values via copying methods of destination types
- Ability to copy inherited fields from embedded structs
- Ability to set a destination struct field as `nil` if it is `zero`
- Ability to copy unexported struct fields
- Ability to copy with extra configuration settings

## Installation

```shell
go get github.com/tiendc/go-deepcopy
```

## Usage

- [First example](#first-example)
- [Copy between struct fields with different names](#copy-between-struct-fields-with-different-names)
- [Skip copying struct fields](#skip-copying-struct-fields)
- [Require copying for struct fields](#require-copying-for-struct-fields)
- [Copy struct fields via struct methods](#copy-struct-fields-via-struct-methods)
- [Copy inherited fields from embedded structs](#copy-inherited-fields-from-embedded-structs)
- [Set destination struct fields as `nil` on `zero`](#set-destination-struct-fields-as-nil-on-zero)
- [PostCopy event method for structs](#postcopy-event-method-for-structs)
- [Copy between structs and maps](#copy-between-structs-and-maps)
- [Configure extra copying behaviors](#configure-extra-copying-behaviors)

### First example

  [Playground](https://go.dev/play/p/CrP_rZlkNzm)

```go
    type SS struct {
        B bool
    }
    type S struct {
        I  int
        U  uint
        St string
        V  SS
    }
    type DD struct {
        B bool
    }
    type D struct {
        I int
        U uint
        X string
        V DD
    }
    src := []S{{I: 1, U: 2, St: "3", V: SS{B: true}}, {I: 11, U: 22, St: "33", V: SS{B: false}}}
    var dst []D
    _ = deepcopy.Copy(&dst, &src) // NOTE: it is recommended that you always pass address of `src` to the function
                                  // when copy structs having unexported fields such as `time.Time`.
    for _, d := range dst {
        fmt.Printf("%+v\n", d)
    }

    // Output:
    // {I:1 U:2 X: V:{B:true}}
    // {I:11 U:22 X: V:{B:false}}
```

### Copy between struct fields with different names

  [Playground](https://go.dev/play/p/WchsGRns0O-)

```go
    type S struct {
        X  int    `copy:"Key"` // 'Key' is used to match the fields
        U  uint
        St string
    }
    type D struct {
        Y int     `copy:"Key"`
        U uint
    }
    src := []S{{X: 1, U: 2, St: "3"}, {X: 11, U: 22, St: "33"}}
    var dst []D
    _ = deepcopy.Copy(&dst, &src)

    for _, d := range dst {
        fmt.Printf("%+v\n", d)
    }

    // Output:
    // {Y:1 U:2}
    // {Y:11 U:22}
```

### Skip copying struct fields

- By default, matching fields will be copied. If you don't want to copy a field, use tag value `-`.

  [Playground](https://go.dev/play/p/8KPe1Susjp1)

```go
    // S and D both have `I` field, but we don't want to copy it
    // Tag `-` can be used in both struct definitions or just in one
    type S struct {
        I  int
        U  uint
        St string
    }
    type D struct {
        I int `copy:"-"`
        U uint
    }
    src := []S{{I: 1, U: 2, St: "3"}, {I: 11, U: 22, St: "33"}}
    var dst []D
    _ = deepcopy.Copy(&dst, &src)

    for _, d := range dst {
        fmt.Printf("%+v\n", d)
    }

    // Output:
    // {I:0 U:2}
    // {I:0 U:22}
```

### Require copying for struct fields

  [Playground](https://go.dev/play/p/yDlLsv1wBnf)

```go
    type S struct {
        U  uint
        St string
    }
    type D struct {
        I int `copy:",required"`
        U uint
    }
    src := []S{{U: 2, St: "3"}, {U: 22, St: "33"}}
    var dst []D
    err := deepcopy.Copy(&dst, &src)
    if err != nil {
        fmt.Println("error:", err)
    }

    // Output:
    // error: ErrFieldRequireCopying: struct field 'main.D[I]' requires copying
```

### Copy struct fields via struct methods

- **Note**: If a copying method is defined within a struct, it will have higher priority than matching fields.

  [Playground 1](https://go.dev/play/p/rCawGa5AZh3) /
  [Playground 2](https://go.dev/play/p/vDOhHXyUoyD)

```go
type S struct {
    X  int
    U  uint
    St string
}

type D struct {
    x string
    U uint
}

// Copy method should be in form of `Copy<source-field>` (or key) and return `error` type
func (d *D) CopyX(i int) error {
    d.x = fmt.Sprintf("%d", i)
    return nil
}
```
```go
    src := []S{{X: 1, U: 2, St: "3"}, {X: 11, U: 22, St: "33"}}
    var dst []D
    _ = deepcopy.Copy(&dst, &src)

    for _, d := range dst {
        fmt.Printf("%+v\n", d)
    }

    // Output:
    // {x:1 U:2}
    // {x:11 U:22}
```

### Copy inherited fields from embedded structs

- This is default behaviour from v1, for lower versions, you can use custom copying function
to achieve the same result.

  [Playground 1](https://go.dev/play/p/Zjj12AMRYXt) /
  [Playground 2](https://go.dev/play/p/cJGLqpPVHXI)

```go
    type SBase struct {
        St string
    }
    // Source struct has an embedded one
    type S struct {
        SBase
        I int
    }
    // but destination struct doesn't
    type D struct {
        I  int
        St string
    }

    src := []S{{I: 1, SBase: SBase{"abc"}}, {I: 11, SBase: SBase{"xyz"}}}
    var dst []D
    _ = deepcopy.Copy(&dst, &src)

    for _, d := range dst {
        fmt.Printf("%+v\n", d)
    }

    // Output:
    // {I:1 St:abc}
    // {I:11 St:xyz}
```

### Set destination struct fields as `nil` on `zero`

- This is a new feature from v1.5.0. This applies to destination fields of type `pointer`, `interface`,
`slice`, and `map`. When their values are zero after copying, they will be set as `nil`. This is very
convenient when you don't want to send something like a date of `0001-01-01` to client, you want to send
`null` instead.

[Playground 1](https://go.dev/play/p/GO6VExVOLei) /
[Playground 2](https://go.dev/play/p/u0zMHx9UWjA) /
[Playground 3](https://go.dev/play/p/ZpA8DkQ9-7f)

```go
    // Source struct has a time.Time field
    type S struct {
        I    int
        Time time.Time
    }
    // Destination field must be a nullable value such as `*time.Time` or `interface{}`
    type D struct {
        I    int
        Time *time.Time `copy:",nilonzero"` // make sure to use this tag
    }

    src := []S{{I: 1, Time: time.Time{}}, {I: 11, Time: time.Now()}}
    var dst []D
    _ = deepcopy.Copy(&dst, &src)

    for _, d := range dst {
        fmt.Printf("%+v\n", d)
    }

    // Output:
    // {I:1 Time:<nil>} (source is a zero time value, destination becomes `nil`)
    // {I:11 Time:2025-02-08 12:31:11...} (source is not zero, so be the destination)
```

### `PostCopy` event method for structs

- This is a new feature from v1.5.0. If a destination struct has PostCopy() method, it will be called after copying.

  [Playground](https://go.dev/play/p/fGhGZumaRUD)

```go
    type S struct {
        I  int
        St string
    }
    type D struct {
        I  int
        St string
    }
    // PostCopy must be defined on struct pointer, not value
    func (d *D) PostCopy(src any) error {
        d.I *= 2
        d.St += d.St
        return nil
    }

    src := []S{{I: 1, St: "a"}, {I: 11, St: "aa"}}
    var dst []D
    _ = deepcopy.Copy(&dst, &src)

    for _, d := range dst {
        fmt.Printf("%+v\n", d)
    }

    // Output:
    // {I:2 St:aa}
    // {I:22 St:aaaa}
```

### Copy between structs and maps

  [Playground](https://go.dev/play/p/eS8RWB8dKmL)

```go
    type D struct {
        I int  `copy:"i"`
        U uint `copy:"u"`
    }

    src := map[string]any{"i": 1, "u": 2, "s": "abc"}
    var dst D
    err := deepcopy.Copy(&dst, &src)
    if err != nil {
        fmt.Println("error:", err)
    }
    fmt.Printf("Result struct: %+v\n", dst)

    src2 := D{I: 11, U: 22}
    dst2 := map[string]any{}
    err = deepcopy.Copy(&dst2, &src2)
    if err != nil {
        fmt.Println("error:", err)
    }
    fmt.Printf("Result map: %+v\n", dst2)

    // Output:
    // Result struct: {I:1 U:2}
    // Result map: map[i:11 u:22]
```

### Configure extra copying behaviors

- Not allow to copy between `ptr` type and `value` (default is `allow`)

  [Playground](https://go.dev/play/p/ZYzGaCNwp2i)

```go
    type S struct {
        I  int
        U  uint
    }
    type D struct {
        I *int
        U uint
    }
    src := []S{{I: 1, U: 2}, {I: 11, U: 22}}
    var dst []D
    err := deepcopy.Copy(&dst, &src, deepcopy.CopyBetweenPtrAndValue(false))
    fmt.Println("error:", err)

    // Output:
    // error: ErrTypeNonCopyable: int -> *int
```

- Ignore ErrTypeNonCopyable, the process will not return that kind of error, but some copyings won't be performed.
  
  [Playground 1](https://go.dev/play/p/YPz49D_oiTY) /
  [Playground 2](https://go.dev/play/p/DNrBJUP-rrM)

```go
    type S struct {
        I []int
        U uint
    }
    type D struct {
        I int
        U uint
    }
    src := []S{{I: []int{1, 2, 3}, U: 2}, {I: []int{1, 2, 3}, U: 22}}
    var dst []D
    // The copy will succeed with ignoring copy of field `I`
    _ = deepcopy.Copy(&dst, &src, deepcopy.IgnoreNonCopyableTypes(true))

    for _, d := range dst {
        fmt.Printf("%+v\n", d)
    }

    // Output:
    // {I:0 U:2}
    // {I:0 U:22}
```

## Benchmarks

### Go-DeepCopy vs ManualCopy vs Other Libs

This benchmark is done on go-deepcopy v1.6.0 using Go 1.24.2

**Copy between 2 different struct types** 
  [Benchmark code](https://gist.github.com/tiendc/0a739fd880b9aac5373de95458d54808)

```
Go-DeepCopy
Go-DeepCopy-10         	 1734240	       682.3 ns/op	     344 B/op	       4 allocs/op
ManualCopy
ManualCopy-10          	32983267	        35.59 ns/op	      80 B/op	       1 allocs/op
JinzhuCopier
JinzhuCopier-10        	  146428	      8138 ns/op	     912 B/op	      40 allocs/op
ulule/deepcopier
ulule/deepcopier-10    	   47137	     25717 ns/op	   50752 B/op	     550 allocs/op
mohae/deepcopy
mohae/deepcopy-10      	  597488	      1828 ns/op	    1208 B/op	      42 allocs/op
barkimedes/deepcopy
barkimedes/deepcopy-10 	  528232	      2206 ns/op	    1464 B/op	      15 allocs/op
mitchellh/copystructure
mitchellh/copystructure-10   123484	      9545 ns/op	    7592 B/op	     191 allocs/op
```

**Copy between the same struct type**
  [Benchmark code](https://gist.github.com/tiendc/502725af830d454382234e8dca22dbdf)

```
Go-DeepCopy
Go-DeepCopy-10         	 2693502	       438.0 ns/op	     248 B/op	       4 allocs/op
ManualCopy
ManualCopy-10          	36577604	        32.17 ns/op	      80 B/op	       1 allocs/op
JinzhuCopier
JinzhuCopier-10        	  187950	      6468 ns/op	     824 B/op	      39 allocs/op
ulule/deepcopier
ulule/deepcopier-10    	   50193	     23170 ns/op	   44768 B/op	     486 allocs/op
mohae/deepcopy
mohae/deepcopy-10      	 1000000	      1083 ns/op	     640 B/op	      26 allocs/op
barkimedes/deepcopy
barkimedes/deepcopy-10 	  886911	      1345 ns/op	     888 B/op	      13 allocs/op
mitchellh/copystructure
mitchellh/copystructure-10   212216	      5559 ns/op	    4552 B/op	     116 allocs/op
```

## Contributing

- You are welcome to make pull requests for new functions and bug fixes.

## License

- [MIT License](LICENSE)

[doc-img]: https://pkg.go.dev/badge/github.com/tiendc/go-deepcopy
[doc]: https://pkg.go.dev/github.com/tiendc/go-deepcopy
[gover-img]: https://img.shields.io/badge/Go-%3E%3D%201.18-blue
[gover]: https://img.shields.io/badge/Go-%3E%3D%201.18-blue
[ci-img]: https://github.com/tiendc/go-deepcopy/actions/workflows/go.yml/badge.svg
[ci]: https://github.com/tiendc/go-deepcopy/actions/workflows/go.yml
[cov-img]: https://codecov.io/gh/tiendc/go-deepcopy/branch/main/graph/badge.svg
[cov]: https://codecov.io/gh/tiendc/go-deepcopy
[rpt-img]: https://goreportcard.com/badge/github.com/tiendc/go-deepcopy
[rpt]: https://goreportcard.com/report/github.com/tiendc/go-deepcopy


go-deepcopy

Library to simplify access struct fields with Go's expression in reflection

# gpath [![Go Documentation](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)][godoc] [![Travis](https://img.shields.io/travis/tenntenn/gpath.svg?style=flat-square)][travis] [![Go Report Card](https://goreportcard.com/badge/github.com/tenntenn/gpath)](https://goreportcard.com/report/github.com/tenntenn/gpath) [![codecov](https://codecov.io/gh/tenntenn/gpath/branch/master/graph/badge.svg)](https://codecov.io/gh/tenntenn/gpath)

[godoc]: http://godoc.org/github.com/tenntenn/gpath
[travis]: https://travis-ci.org/tenntenn/gpath

`gpath` is a Go package to access a field by a path using `reflect` pacakge.

A path is represented by a Go's expression such as `A.B.C[0]`.
You can use selector and index expressions into a path.

See usage and example in [GoDoc](https://godoc.org/github.com/tenntenn/gpath).

*NOTE*: This package is experimental and may make backward-incompatible changes.

## Install

Use go get:

```
$ go get github.com/tenntenn/gpath
```

## Usage

All usage are described in [GoDoc](https://godoc.org/github.com/tenntenn/gpath).

[mercari/go-httpdoc](https://github.com/mercari/go-httpdoc) is a good example for gpath.


gpath

A common enumeration struct based on generics and reflection that allows you to quickly define enumerations and use a set of useful default methods

## Go enumeration template implementation

[![License](https://img.shields.io/badge/license-Apache%202-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
[![Go Report Card](https://goreportcard.com/badge/github.com/lvyahui8/goenum)](https://goreportcard.com/report/github.com/lvyahui8/goenum)
[![codecov](https://codecov.io/gh/lvyahui8/goenum/graph/badge.svg?token=YBV3TH2HQU)](https://codecov.io/gh/lvyahui8/goenum)

[中文文档](./README_CN.md)

### How to define and use enumerations?

**Simply embed goenum.Enum into a struct to define an enumeration type and automatically obtain a set of instance methods and utility functions.**

```shell
go get github.com/lvyahui8/goenum
```

```go
import "github.com/lvyahui8/goenum"

// Declaring an enumeration type
type State struct {
    goenum.Enum
}

// Defines a set of enumeration instances
var (
    Created = goenum.NewEnum[State]("Created")
    Running = goenum.NewEnum[State]("Running")
    Success = goenum.NewEnum[State]("Success")
)

// Usage
Created.Name() // string "Created"
Created.Ordinal() // int 0
Created.Compare(Running) //  < 0 : Created < Running
Created.String() // Created
json.Marshal(Created) // \"Created\"
IsValidEnum[State]("Created") // true
s,valid := goenum.ValueOf[State]("Created") // s: Created(struct instance) ,valid = true
Created.Equals(s) // true
s,valid := goenum.ValueOf[State]("cReaTed") //  s: Created(struct instance) ,valid = true
Created.Equals(s) // true
goenum.Values[State]() // equals []State{Created,Running,Success}
Size[State]() // = 3
```

More Examples [examples](internal)

### Instance Methods

```go
type EnumDefinition interface {
    fmt.Stringer
    json.Marshaler
    encoding.TextMarshaler
    // Name The name of the enumeration. The enumeration names of the same Type must be unique.
    Name() string
    // Equals Compare with another enumeration. Only return true if both Type and Name are the same
    Equals(other EnumDefinition) bool
    // Type String representation of enumeration type
    Type() string
    // Ordinal Get the ordinal of the enumeration, starting from zero and increasing in declared order.
    Ordinal() int
    // Compare -Compare with the ordinal value of another enumeration
    Compare(other EnumDefinition) int
}
```

### Utility functions

- ValueOf: Find an enumeration instance based on the string, and return a zero value if not found
- ValueOfIgnoreCase: Ignoring case to obtain enumeration instances.
- Values: Return all enumeration instances. The returned slice are sorted by ordinal
- Size: Number of instances of specified enumeration type
- GetEnumMap: Get all enumeration instances of the specified type.
- EnumNames: Get the names of a batch of enumerations.
- GetEnums: Obtain a batch of enumeration instances based on the enumeration name list
- IsValidEnum: Determine if the incoming string is a valid enumeration 

```go
func TestHelpers(t *testing.T) {
	t.Run("NewEnum", func(t *testing.T) {
		defer func() {
			err := recover()
			require.NotNil(t, err)
			require.Equal(t, "Enum must be unique", err)
		}()
		_ = goenum.NewEnum[Role]("Owner")
	})
	t.Run("ValueOf", func(t *testing.T) {
		r, valid := goenum.ValueOf[Role]("Owner")
		require.True(t, valid)
		require.True(t, Owner.Equals(r))
		r, valid = goenum.ValueOf[Role]("Owner")
		require.True(t, valid)
		require.False(t, Developer.Equals(r))
	})
	t.Run("ValueOfIgnoreCase", func(t *testing.T) {
		r, valid := goenum.ValueOfIgnoreCase[Role]("oWnEr")
		require.True(t, valid)
		require.True(t, Owner.Equals(r))
		r, valid = goenum.ValueOfIgnoreCase[Role]("oWnEr")
		require.True(t, valid)
		require.False(t, Reporter.Equals(r))
	})
	t.Run("Values", func(t *testing.T) {
		require.True(t, reflect.DeepEqual([]Role{Reporter, Developer, Owner}, goenum.Values[Role]()))
	})
	t.Run("GetEnumMap", func(t *testing.T) {
		enumMap := goenum.GetEnumMap[Role]()
		require.True(t, len(enumMap) == 3)
		role, exist := enumMap["Owner"]
		require.True(t, exist)
		require.True(t, role.Equals(Owner))
	})
	t.Run("EnumNames", func(t *testing.T) {
		require.True(t, reflect.DeepEqual([]string{"Owner", "Developer"}, goenum.EnumNames(Owner, Developer)))
	})
	t.Run("GetEnums", func(t *testing.T) {
		res, valid := goenum.GetEnums[Role]("Owner", "Developer")
		require.True(t, valid)
		require.True(t, reflect.DeepEqual([]Role{Owner, Developer}, res))
		_, valid = goenum.GetEnums[Role]("a", "b")
		require.False(t, valid)
	})
	t.Run("IsValidEnum", func(t *testing.T) {
		require.True(t, goenum.IsValidEnum[Role]("Owner"))
		require.False(t, goenum.IsValidEnum[Role]("Test"))
	})
}
```

### More features

#### Complex enumeration initialization

The second parameter in the NewEnum function, if a Src is passed in, NewEnum will use the passed object to construct an enumeration instance.

example code [gitlab_role_perms](internal/role_enums.go)

```go
type Module struct {
	goenum.Enum
	perms    []Permission
	basePath string
}

func (m Module) GetPerms() []Permission {
	return m.perms
}

func (m Module) BasePath() string {
	return m.basePath
}

// 定义模块
var (
	Issues        = goenum.NewEnum[Module]("Issues", Module{perms: []Permission{AddLabels, AddTopic}, basePath: "/issues/"})
	MergeRequests = goenum.NewEnum[Module]("MergeRequests", Module{perms: []Permission{ViewMergeRequest, ApproveMergeRequest, DeleteMergeRequest}, basePath: "/merge/"})
)
```

#### JSON serialization and deserialization support for enumerating instances

JSON serialization is already supported by default. Restricted by the implementation of the go JSON library, enumeration classes are required to implement JSON Unmarshaler interface to realize deserialization. Call Unmarshal tool function in the interface to obtain enumeration instances.

```go
type Member struct {
	Roles []Role
}

type Role struct {
	goenum.Enum
	perms []Permission
}

func (r *Role) UnmarshalJSON(data []byte) (err error) {
	role, err := goenum.Unmarshal[Role](data)
	if err == nil {
		*r = role
	}
	return
}

t.Run("jsonMarshal", func(t *testing.T) {
    bytes, err := json.Marshal(Developer)
    require.Nil(t, err)
    require.Equal(t, "\"Developer\"", string(bytes))
    member := Member{Roles: []Role{Reporter, Owner}}
    bytes, err = json.Marshal(member)
    require.Nil(t, err)
    require.Equal(t, "{\"Roles\":[\"Reporter\",\"Owner\"]}", string(bytes))
})
t.Run("jsonUnmarshal", func(t *testing.T) {
    newMember := Member{}
    err := json.Unmarshal([]byte("{\"Roles\":[\"Reporter\",\"Owner\"]}"), &newMember)
    require.Nil(t, err)
    require.True(t, reflect.DeepEqual([]Role{Reporter, Owner}, newMember.Roles))
})
```

#### EnumSet

api声明
```go
// EnumSet Enumerate sets. Usually used for high-performance lookup when
// there are many instances of a certain type of enumeration.
type EnumSet[E EnumDefinition] interface {
    fmt.Stringer
    json.Marshaler
    // Add -Add an element to Set. If successful, return true. If it already exists, return false
    Add(e E) bool
    // AddRange According to the ordinal of the enumeration,
    // add a continuous section of the enumeration and
    // return the actual number added (excluding those that already exist)
    AddRange(begin, end E) int
    // Remove Delete element. If the deletion is successful, return true.
    // If the element does not exist, return false
    Remove(e E) bool
    // RemoveRange  According to the ordinal of the enumeration,
    // continuously delete a segment of the enumeration and
    // return the actual number of deletions  (excluding those that non-exist)
    RemoveRange(begin, end E) int
    // IsEmpty Is Set empty
    IsEmpty() bool
    // Clear -Clear set
    Clear()
    // Len The current number of enumeration instances within the Set
    Len() int
    // Contains Does it contain the specified enumeration?
    // Returns false if there is only one that does not exist in the Set
    Contains(enums ...E) bool
    // ContainsAll  Determine if it contains another enumSet (subset relationship)
    ContainsAll(set EnumSet[E]) bool
    // Equals Determine if two EnumSets are the same
    Equals(set EnumSet[E]) bool
    // Each Set iteration method, if f method returns false, abort iteration
    Each(f func(e E) bool)
    // Names Returns the Name representation of an existing enumeration instance in the set
    Names() []string
    // Clone Deep copy to obtain a new set
    Clone() EnumSet[E]
}
```

EnumSet usage

```go
stmtSet := NewUnsafeEnumSet[Statement]()

stmtSet.Add(Decl)
stmtSet.IsEmpty()
stmtSet.Contains(Decl)
stmtSet.Len() == 1
stmtSet.AddRange(Comm, Range)
stmtSet.Remove(Decl)
```

Example code [enum_set_test](enum_set_test.go)

### ValueOf Performance

Don't worry about any performance issues, reflection calls are mostly only used in NewEnum methods, and other methods will try to avoid reflection calls as much as possible.

```text
goos: linux
goarch: arm64
pkg: github.com/lvyahui8/goenum/internal
BenchmarkValueOf/ValueOf-4             1000000000             0.0002492 ns/op           0 B/op           0 allocs/op
BenchmarkValueOf/ValueOf-4             1000000000             0.0002966 ns/op           0 B/op           0 allocs/op
BenchmarkValueOf/ValueOf-4             1000000000             0.0002713 ns/op           0 B/op           0 allocs/op
BenchmarkValueOf/ValueOfIgnoreCase-4             1000000000             0.002228 ns/op           0 B/op           0 allocs/op
BenchmarkValueOf/ValueOfIgnoreCase-4             1000000000             0.002611 ns/op           0 B/op           0 allocs/op
BenchmarkValueOf/ValueOfIgnoreCase-4             1000000000             0.002606 ns/op           0 B/op           0 allocs/op
PASS
ok      github.com/lvyahui8/goenum/internal    0.097s
```


goenum

Package for fast copying structs of different types

# Package for fast copying structs of different types

[![GoDev](https://img.shields.io/static/v1?label=godev&message=reference&color=00add8)][godev] [![Go Report Card](https://goreportcard.com/badge/github.com/gotidy/copy)][goreport] [![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

[godev]: https://pkg.go.dev/github.com/gotidy/copy
[goreport]: https://goreportcard.com/report/github.com/gotidy/copy

This package is meant to make copying of structs to/from others structs a bit easier.

Nested structures, embedded types, pointers, sql null types are supported.

## Installation

```sh
go get -u github.com/gotidy/copy
```

## Example

```go
type Person struct {
    Name       string
    MiddleName *string
    Surname    string
}

type User struct {
    Person
    Email   string
    Age     int8
    Married bool
}

type Employee struct {
    Name       string
    MiddleName string
    Surname    string
    Email      string
    Age        int
}

src := User{
    Person: Person{
        Name:       "John",
        MiddleName: nil,
        Surname:    "Smith",
    },
    Email:   "john.smith@joy.me",
    Age:     33,
    Married: false,
}
dst := Employee{}

copiers := copy.New() // New("json")
copiers.Copy(&dst, &src)

// Or more fast use case is to create the type specific copier.

copier := copiers.Get(&Employee{}, &User{}) // Created once for a pair of types.
copier.Copy(&dst, &src)

```

## Alternative projects

- [ulule/Deepcopier](https://github.com/ulule/deepcopier)
- [jinzhu/Copier](https://github.com/jinzhu/copier)

### [Benchmark](https://github.com/gotidy/copy-bench)

Benchmarks source code can be found [here](https://github.com/gotidy/copy-bench)

```sh
go test -bench=. -benchmem ./...
goos: darwin
goarch: amd64
pkg: github.com/gotidy/copy-bench
BenchmarkManualCopy-12         177310519         6.92 ns/op          0 B/op        0 allocs/op
BenchmarkCopiers-12             13476417         84.1 ns/op          0 B/op        0 allocs/op
BenchmarkCopier-12              40226689         27.5 ns/op          0 B/op        0 allocs/op
BenchmarkJinzhuCopier-12          407480         2711 ns/op       2480 B/op       34 allocs/op
BenchmarkDeepcopier-12            262836         4346 ns/op       4032 B/op       73 allocs/op
PASS
ok      github.com/gotidy/copy-bench    6.922s
```

See the [documentation][godev] for more information.

## License

[Apache 2.0](https://github.com/gotidy/copy/blob/master/LICENSE)


copy

# Deepcopier

[![Build Status](https://secure.travis-ci.org/ulule/deepcopier.svg?branch=master)](http://travis-ci.org/ulule/deepcopier)

This package is meant to make copying of structs to/from others structs a bit easier.

## Installation

```bash
go get -u github.com/ulule/deepcopier
```

## Usage

```golang
// Deep copy instance1 into instance2
Copy(instance1).To(instance2)

// Deep copy instance1 into instance2 and passes the following context (which
// is basically a map[string]interface{}) as first argument
// to methods of instance2 that defined the struct tag "context".
Copy(instance1).WithContext(map[string]interface{}{"foo": "bar"}).To(instance2)

// Deep copy instance2 into instance1
Copy(instance1).From(instance2)

// Deep copy instance2 into instance1 and passes the following context (which
// is basically a map[string]interface{}) as first argument
// to methods of instance1 that defined the struct tag "context".
Copy(instance1).WithContext(map[string]interface{}{"foo": "bar"}).From(instance2)
```

Available options for `deepcopier` struct tag:

| Option    | Description                                                          |
| --------- | -------------------------------------------------------------------- |
| `field`   | Field or method name in source instance                              |
| `skip`    | Ignores the field                                                    |
| `context` | Takes a `map[string]interface{}` as first argument (for methods)     |
| `force`   | Set the value of a `sql.Null*` field (instead of copying the struct) |

**Options example:**

```golang
type Source struct {
    Name                         string
    SkipMe                       string
    SQLNullStringToSQLNullString sql.NullString
    SQLNullStringToString        sql.NullString

}

func (Source) MethodThatTakesContext(c map[string]interface{}) string {
    return "whatever"
}

type Destination struct {
    FieldWithAnotherNameInSource      string         `deepcopier:"field:Name"`
    SkipMe                            string         `deepcopier:"skip"`
    MethodThatTakesContext            string         `deepcopier:"context"`
    SQLNullStringToSQLNullString      sql.NullString 
    SQLNullStringToString             string         `deepcopier:"force"`
}

```

Example:

```golang
package main

import (
    "fmt"
 
    "github.com/ulule/deepcopier"
)

// Model
type User struct {
    // Basic string field
    Name  string
    // Deepcopier supports https://golang.org/pkg/database/sql/driver/#Valuer
    Email sql.NullString
}

func (u *User) MethodThatTakesContext(ctx map[string]interface{}) string {
    // do whatever you want
    return "hello from this method"
}

// Resource
type UserResource struct {
    DisplayName            string `deepcopier:"field:Name"`
    SkipMe                 string `deepcopier:"skip"`
    MethodThatTakesContext string `deepcopier:"context"`
    Email                  string `deepcopier:"force"`

}

func main() {
    user := &User{
        Name: "gilles",
        Email: sql.NullString{
            Valid: true,
            String: "gilles@example.com",
        },
    }

    resource := &UserResource{}

    deepcopier.Copy(user).To(resource)

    fmt.Println(resource.DisplayName)
    fmt.Println(resource.Email)
}
```

Looking for more information about the usage?

We wrote [an introduction article](https://github.com/ulule/deepcopier/blob/master/examples/rest-usage/README.rst).
Have a look and feel free to give us your feedback.

## Contributing

* Ping us on twitter [@oibafsellig](https://twitter.com/oibafsellig), [@thoas](https://twitter.com/thoas)
* Fork the [project](https://github.com/ulule/deepcopier)
* Help us improving and fixing [issues](https://github.com/ulule/deepcopier/issues)

Don't hesitate ;)


Deepcopier

Golang source code parsing, usage like reflect package

# gotype

Golang source code parsing, usage like reflect package

[![Go Report Card](https://goreportcard.com/badge/github.com/wzshiming/gotype)](https://goreportcard.com/report/github.com/wzshiming/gotype)
[![Go Reference](https://pkg.go.dev/badge/github.com/wzshiming/gotype.svg)](https://pkg.go.dev/github.com/wzshiming/gotype)
[![GitHub license](https://img.shields.io/github/license/wzshiming/gotype.svg)](https://github.com/wzshiming/gotype/blob/master/LICENSE)

- [English](https://github.com/wzshiming/gotype/blob/master/README.md)
- [简体中文](https://github.com/wzshiming/gotype/blob/master/README_cn.md)

## Usage

[API Documentation](https://pkg.go.dev/github.com/wzshiming/gotype)

[Examples](https://github.com/wzshiming/gotype/blob/master/cmd/pkgimport/main.go)

## License

Licensed under the MIT License. See [LICENSE](https://github.com/wzshiming/gotype/blob/master/LICENSE) for the full license text.


gotype

[![Go Reference](https://pkg.go.dev/badge/github.com/rekby/objwalker.svg)](https://pkg.go.dev/github.com/rekby/objwalker)
[![Coverage Status](https://coveralls.io/repos/github/rekby/objwalker/badge.svg?branch=master)](https://coveralls.io/github/rekby/objwalker?branch=master)
[![GoReportCard](https://goreportcard.com/badge/github.com/rekby/objwalker)](https://goreportcard.com/report/github.com/rekby/objwalker)
[![Mentioned in Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go)

Deep walk by object with reflection. Walker.Walk(v interface{}) call callback function for v object, every field if it struct, every item for slice/array and every key and item for map object. It walk for object recursive and call callback for every object in tree.

It has loop protection - for not hang on cycled structured, protection can be disabled if need.

WalkInfo - struct, send as argument to callback function include:

* ```Value``` - reflection.Value object for read/manipulate with it.
* ```DataPointer``` - direct pointer to underly data, for example - pointer to bytes under string, ot pointer to data under slice. It is danger to manipulate it, but can userful for example for compare objects.
* ```Parent``` - parent of the value in travel tree
* and some other hints about Value

```golang
    package main

    import "github.com/rekby/objwalker"

    func main() {
		type S struct {
			Val1  int
			Slice []string
		}

		val := S{
			Val1:  2,
			Slice: []string{"hello", "world"},
		}
		_ = New(func(info *WalkInfo) error {
			fmt.Println(info.Value.Interface())
			return nil
		}).Walk(val)

		// Output:
		// {2 [hello world]}
		// 2
		// [hello world]
		// hello
		// world
	}
```


objwalker

Callers, copiers, getters and setters for go

[![Go Reference](https://pkg.go.dev/badge/github.com/gontainer/reflectpro.svg)](https://pkg.go.dev/github.com/gontainer/reflectpro)
[![Tests](https://github.com/gontainer/reflectpro/actions/workflows/tests.yml/badge.svg)](https://github.com/gontainer/reflectpro/actions/workflows/tests.yml)
[![Coverage Status](https://coveralls.io/repos/github/gontainer/reflectpro/badge.svg?branch=main)](https://coveralls.io/github/gontainer/reflectpro?branch=main)
[![Go Report Card](https://goreportcard.com/badge/github.com/gontainer/reflectpro)](https://goreportcard.com/report/github.com/gontainer/reflectpro)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=gontainer_reflectpro&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=gontainer_reflectpro)

# Reflectpro

Simple, elegant, and intuitive [callers](caller), [copiers](copier), [getters](getter) and [setters](setter).

## Examples

## Caller

In the following example, we have a pointer to `any` that stores a `struct`,
instead of having a direct pointer to a `struct`.
The receiver is a pointer, so eventually we cannot call the given method.
`Caller` handles that by creating a pointer to a copy of that value.

```go
type Person struct {
	name string
	age  int
}

func (p *Person) SetName(n string) {
	p.name = n
}

func Example() {
	var p any
	p := &Person{age: 25}
	_, _ = caller.CallMethod(p, "SetName", []any{"Mary"}, false)
	fmt.Printf("%+v\n", p)
	// Output: &{name:Mary age:25}
}
```

## Copier

```go
var (
    from = []any{int(1), uint(2), float32(3), float64(4)}
    to   []uint64
)
_ = copier.Copy(from, &to, true) // convert
fmt.Printf("%#v\n", to)
// Output: []uint64{0x1, 0x2, 0x3, 0x4}
```

## Getter

In the following example, we read an unexported field of the given struct.

```go
person := struct {
    name string
}{
    name: "Mary",
}
v, _ := getter.Get(person, "name")
fmt.Println(v)
// Output: Mary
```

## Setter

In the following example, we have a pointer to `any` that stores a `struct`,
instead of having a direct pointer to a `struct`. Since it is an `unaddressable value`,
the `reflect` package from the standard library does not allow assigning a new value to this field.
`Setter` handles that by creating an addressable copy.

```go
var person any
person = struct {
    name string
}{}
_ = setter.Set(&person, "name", "Mary", false)
fmt.Println(person)
// Output: {Mary}
```


reflectpro

Helpers for working with reflection: struct tag parsing; recursive walking; fill value from string

# reflectutils - utility functions for working with Golang's reflect package

[![GoDoc](https://godoc.org/github.com/muir/reflectutils?status.png)](https://pkg.go.dev/github.com/muir/reflectutils)
![unit tests](https://github.com/muir/reflectutils/actions/workflows/go.yml/badge.svg)
[![report card](https://goreportcard.com/badge/github.com/muir/reflectutils)](https://goreportcard.com/report/github.com/muir/reflectutils)
[![codecov](https://codecov.io/gh/muir/reflectutils/branch/main/graph/badge.svg)](https://codecov.io/gh/muir/reflectutils)

Install:

	go get github.com/muir/reflectutils

---

Reflectutils is simply a repository for functions useful for working with Golang's reflect package.

Here's the highlights:

## Walking structures

```go
func WalkStructElements(t reflect.Type, f func(reflect.StructField) bool)
```

Recursively walking a struct with reflect has a pitfalls: 

1. It isn't recurse with respect to embeded structs
1. The `Index` field of `reflect.Structfield` of embedded structs is not relative to your starting point.

[WalkStructElements()](https://pkg.go.dev/github.com/muir/reflectutils#WalkStructElements) walks 
embedded elements and it updates `StructField.Index` so that it is
relative to the root struct that was passed in.

## Setting elements

```go
func MakeStringSetter(t reflect.Type, optArgs ...StringSetterArg) (func(target reflect.Value, value string) error, error)
```

[MakeStringSetter()](https://pkg.go.dev/github.com/muir/reflectutils#MakeStringSetter) 
returns a function that can be used to assing to `reflect.Value` given a
string value.  It can handle arrays and slices (splits strings on commas).

## Parsing struct tags

Use [SplitTag()](https://pkg.go.dev/github.com/muir/reflectutils#SplitTag) to break a struct
tag into it's elements and then use [Tag.Fill()](https://pkg.go.dev/github.com/muir/reflectutils#Tag.Fill)
to parse it into a struct.

For example:

```go
type TagInfo struct {
	Name	string	`pt:"0"`     // positional, first argument
	Train	bool	`pt:"train"` // boolean: true: "train", "train=true"; false: "!train", "train=false"
	Count	int	`pt:"count"` // integer value will be parsed
}

st := reflect.StructTag(`foo:"bar,!train,count=9"`)
var tagInfo TagInfo
err := GetTag(st, "foo").Fill(&tagInfo)

// tagInfo.Name will be "bar"
// tagInfo.Train will be false
// tagInfo.Count will be 9
```

## Type names

The `TypeName()` function exists to disambiguate between type names that are
versioned.  `reflect.Type.String()` will hides package versions.  This doesn't
matter unless you've, unfortunately, imported multiple versions of the same
package.  

## Default filler

The `FillInDefaultValues()` function will look at for a struct tag named "default"
and use that value to fill in values where no value has been set.

## Development status

Reflectutils is used by several packages.  Backwards compatability is expected.



The Best Go Libraries For Reflection (9)