limitations under the License.
*/

package runtime

import (
	"bytes"
	"io"
)

// Splice is the interface that wraps the Splice method.
//
// Splice moves data from given slice without copying the underlying data for
// efficiency purpose. Therefore, the caller should make sure the underlying
// data is not changed later.
type Splice interface {
	Splice([]byte)
	io.Writer

/**
 * An indexed store that maps a key to a file or directory.
 *
 * Most implementations do not provide locking, which must be coordinated by the caller.
 */
public interface FileStore<K> {
    /**
     * Moves the given file into the store.
     */
    LocallyAvailableResource move(K key, File source) throws FileStoreException;

    /**
     * Adds an entry to the store, using the given action to produce the file.
     *

	if err != nil {
		return err
	}
	defer func() {
		_ = destFile.Close()
	}()

	_, err = io.Copy(destFile, sourceFile)

	return err
}

// MoveFile moves a file from src to dest.
func MoveFile(src, dest string) error {
	err := os.Rename(src, dest)
	if err != nil && strings.Contains(err.Error(), "invalid cross-device link") {

namespace mlir {
namespace TFTPU {

namespace {

#define GEN_PASS_DEF_TPUPARALLELEXECUTESINKRESOURCEWRITEPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

// A pass that moves `tf.AssignVariableOp` into a `tf_device.parallel_execute`
// region if the `tf.AssignVariableOp` is the only consumer of a
// `tf_device.parallel_execute` result. This will allow

    // Specifically requesting the GradleUserHomeTemporaryFileProvider to ensure that the temporary files are created on the same file system as the target directory
    // This is a prerequisite for atomic moves in most cases, which are used in the provisionFromArchive method
    private final GradleUserHomeTemporaryFileProvider temporaryFileProvider;

    @Inject
    public DefaultJdkCacheDirectory(

	"runtime"
	"testing"
)

// The tests in this file test the function start line metadata included in
// _func and inlinedCall. TestStartLine hard-codes the start lines of functions
// in this file. If code moves, the test will need to be updated.
//
// The "start line" of a function should be the line containing the func
// keyword.

func normalFunc() int {
	return callerStartLine(false)
}

}

// moveFiles moves files from one directory to another.
func moveFiles(files map[string]string) error {
	filesToRecover := make(map[string]string, len(files))
	for from, to := range files {
		if err := os.Rename(from, to); err != nil {
			return rollbackFiles(filesToRecover, err)
		}
		filesToRecover[to] = from
	}
	return nil
}

// rollbackFiles moves the files back to the original directory.

# If 'go get -u' finds an upgrade candidate that isn't viable,
# but some other upgraded module's requirement moves past it
# (for example, to a higher prerelease), then we should accept
# the transitive upgrade instead of trying lower roots.

go get -v -u . example.net/b@v0.1.0
cmp go.mod go.mod.want

-- go.mod --
module example

go 1.17

require (
	example.net/a v0.1.0
	example.net/b v0.1.0
	example.net/c v0.1.0
)

}

// MoveToFront moves element e to the front of list l.
// If e is not an element of l, the list is not modified.
// The element must not be nil.
func (l *_List[T]) MoveToFront(e *_Element[T]) {
	if e.list != l || l.root.next == e {
		return
	}
	// see comment in _List.Remove about initialization of l
	l.move(e, &l.root)
}

// MoveToBack moves element e to the back of list l.

	UpdatedAt time.Time
}

func (l *lastDayTierStats) addStats(ts tierStats) {
	now := time.Now()
	l.forwardTo(now)

	nowIdx := now.Hour()
	l.Bins[nowIdx] = l.Bins[nowIdx].add(ts)
}

// forwardTo moves time to t, clearing entries between last update and t.
func (l *lastDayTierStats) forwardTo(t time.Time) {
	if t.IsZero() {
		t = time.Now()
	}

	since := t.Sub(l.UpdatedAt).Hours()