### Using Custom Skip Option in Go Copy

Source: https://github.com/otiai10/copy/blob/main/README.md

Illustrates how to use the `Options` struct to customize the copy behavior. This example specifically shows how to define a `Skip` function within the options to exclude files or directories based on a condition, such as skipping `.git` directories, and then passes these options to the `Copy` function.

```Go
// For example...
opt := Options{
	Skip: func(info os.FileInfo, src, dest string) (bool, error) {
		return strings.HasSuffix(src, ".git"), nil
	},
}
err := Copy("your/directory", "your/directory.copy", opt)
```

--------------------------------

### Setting PermissionControl with AddPermission (Go)

Source: https://github.com/otiai10/copy/blob/main/test/data/case14/README.md

Demonstrates how to set the PermissionControl option using the AddPermission helper function with a specific permission mode (0222) in the otiai10/copy library. This is shown as an example of how to use PermissionControl, replacing the obsolete AddPermission option.

```Go
opt.PermissionControl = AddPermission(0222)
```

--------------------------------

### Performing Basic File Copy in Go

Source: https://github.com/otiai10/copy/blob/main/README.md

Demonstrates the basic usage of the `otiai10/copy` library to recursively copy a directory from a source path to a destination path. It shows how to import the library and call the `Copy` function, printing any potential error.

```Go
package main

import (
	"fmt"
	cp "github.com/otiai10/copy"
)

func main() {
	err := cp.Copy("your/src", "your/dest")
	fmt.Println(err) // nil
}
```

--------------------------------

### Defining Copy Options Structure in Go

Source: https://github.com/otiai10/copy/blob/main/README.md

Defines the `Options` struct used by the `otiai10/copy` library to customize the copying process. It details various fields like `OnSymlink`, `OnDirExists`, `OnError`, `Skip`, `PermissionControl`, `Sync`, `PreserveTimes`, `PreserveOwner`, `CopyBufferSize`, `WrapReader`, `FS`, `NumOfWorkers`, and `PreferConcurrent`, explaining their purpose through comments.

```Go
// Options specifies optional actions on copying.
type Options struct {

	// OnSymlink can specify what to do on symlink
	OnSymlink func(src string) SymlinkAction

	// OnDirExists can specify what to do when there is a directory already existing in destination.
	OnDirExists func(src, dest string) DirExistsAction

	// OnError can let users decide how to handle errors (e.g., you can suppress specific error).
	OnError func(src, dest, string, err error) error

	// Skip can specify which files should be skipped
	Skip func(srcinfo os.FileInfo, src, dest string) (bool, error)

	// RenameDestination can rename destination.
	// If not set, nil, it does nothing.
	RenameDestination func(src, dest string) (string, error)

	// PermissionControl can control permission of
	// every entry.
	// When you want to add permission 0222, do like
	//
	//		PermissionControl = AddPermission(0222)
	//
	// or if you even don't want to touch permission,
	//
	//		PermissionControl = DoNothing
	//
	// By default, PermissionControl = PreservePermission
	PermissionControl PermissionControlFunc

	// Sync file after copy.
	// Useful in case when file must be on the disk
	// (in case crash happens, for example),
	// at the expense of some performance penalty
	Sync bool

	// Preserve the atime and the mtime of the entries
	// On linux we can preserve only up to 1 millisecond accuracy
	PreserveTimes bool

	// Preserve the uid and the gid of all entries.
	PreserveOwner bool

	// The byte size of the buffer to use for copying files.
	// If zero, the internal default buffer of 32KB is used.
	// See https://golang.org/pkg/io/#CopyBuffer for more information.
	CopyBufferSize uint

	// If you want to add some limitation on reading src file,
	// you can wrap the src and provide new reader,
	// such as `RateLimitReader` in the test case.
	WrapReader func(src io.Reader) io.Reader

	// If given, copy.Copy refers to this fs.FS instead of the OS filesystem.
	// e.g., You can use embed.FS to copy files from embedded filesystem.
	FS fs.FS

	// NumOfWorkers represents the number of workers used for
	// concurrent copying contents of directories.
	// If 0 or 1, it does not use goroutine for copying directories.
	// Please refer to https://pkg.go.dev/golang.org/x/sync/semaphore for more details.
	NumOfWorkers int64

	// PreferConcurrent is a function to determine whether or not
	// to use goroutine for copying contents of directories.
	// If PreferConcurrent is nil, which is default, it does concurrent
	// copying for all directories.
	// If NumOfWorkers is 0 or 1, this function will be ignored.
	PreferConcurrent func(srcdir, destdir string) (bool, error)
}
```

--------------------------------

### Setting Copy Rate Limit Option in Go

Source: https://github.com/otiai10/copy/blob/main/test/data/case16/README.md

This snippet demonstrates how to set the 'CopyRateLimit' option to a specific value (100 KB/second) to limit the speed of a copy operation. The default value of 0 indicates no limit.

```Go
opt.CopyRateLimit = 100
```

--------------------------------

### Ignoring Errors in Go Copy Operation

Source: https://github.com/otiai10/copy/blob/main/test/data/case17/README.md

This snippet demonstrates how to set the `OnError` option for a copy operation in Go. By assigning a function that returns `nil`, any errors encountered during the copy process will be ignored, allowing the operation to continue instead of stopping.

```go
opt.OnError = func(src, dst string, _ error) error { return nil }
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.