deepcopier

README

Deepcopier

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

Installation

go get -u github.com/ulule/deepcopier

Usage

// 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:

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:

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. Have a look and feel free to give us your feedback.

Contributing

• Ping us on twitter @oibafsellig, @thoas
• Fork the project
• Help us improving and fixing issues

Don't hesitate ;)

Documentation

Index

• Constants
• type DeepCopier
  • func Copy(src interface{}) *DeepCopier
  • func (dc *DeepCopier) From(src interface{}) error
  • func (dc *DeepCopier) To(dst interface{}) error
  • func (dc *DeepCopier) WithContext(ctx map[string]interface{}) *DeepCopier
• type Options
• type TagOptions

Constants

const (
	// TagName is the deepcopier struct tag name.
	TagName = "deepcopier"
	// FieldOptionName is the from field option name for struct tag.
	FieldOptionName = "field"
	// ContextOptionName is the context option name for struct tag.
	ContextOptionName = "context"
	// SkipOptionName is the skip option name for struct tag.
	SkipOptionName = "skip"
	// ForceOptionName is the skip option name for struct tag.
	ForceOptionName = "force"
)

Types

type DeepCopier

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

DeepCopier deep copies a struct to/from a struct.

func Copy

func Copy(src interface{}) *DeepCopier

Copy sets source or destination.

func (*DeepCopier) From

func (dc *DeepCopier) From(src interface{}) error

From sets the given the source as destination and destination as source.

func (*DeepCopier) To

func (dc *DeepCopier) To(dst interface{}) error

To sets the destination.

func (*DeepCopier) WithContext

func (dc *DeepCopier) WithContext(ctx map[string]interface{}) *DeepCopier

WithContext injects the given context into the builder instance.

type Options

type Options struct {
	// Context given to WithContext() method.
	Context map[string]interface{}
	// Reversed reverses struct tag checkings.
	Reversed bool
}

Options are copier options.

type TagOptions

type TagOptions map[string]string

TagOptions is a map that contains extracted struct tag options.