// MoveUp move position up
519165
func MoveUp(db *gorm.DB, value sortingInterface, pos int) error {
	return move(db, value, -pos)
}
388731
func (d *destination) up() {
	d.active = true
	log.Infof("%v: %v backend %v up", d.service.vserver, d.service, d)

	ncc := d.service.vserver.ncc
	if err := ncc.Dial(); err != nil {
		log.Fatalf("%v: failed to connect to NCC: %v", d.service.vserver, err)
	}
	defer ncc.Close()
	if err := ncc.IPVSAddDestination(d.service.ipvsSvc, d.ipvsDst); err != nil {
		log.Fatalf("%v: failed to add destination %v: %v", d.service.vserver, d, err)
	}
}
285316
func (a *Writer) Move(x, y int) (int, error) {
	return a.WriteString(Move(x, y))
}
1063115
func Move(x, y int) string {
	//与x;yf相同？
	return "\033[" + strconv.Itoa(x) + ";" + strconv.Itoa(y) + "H"
}
1610
func (m *Maze) move(x, y int, dir Dir) (nx, ny int, ok bool) {
	nx = x + dirs[dir].δx
	ny = y + dirs[dir].δy
	ok = 0 <= nx && nx < m.w && 0 <= ny && ny < m.h
	return
}
672233
func (g *Game) Move(m *Move) error {
	valid := moveSlice(g.ValidMoves()).find(m)
	if valid == nil {
		return fmt.Errorf("chess: invalid move %s", m)
	}
	g.moves = append(g.moves, valid)
	g.pos = g.pos.Update(valid)
	g.positions = append(g.positions, g.pos)
	g.updatePosition()
	return nil
}
819011
func (base *Base) Move(ctx context.Context, sourcePath string, destPath string) error {
	ctx, done := dcontext.WithTrace(ctx)
	defer done("%s.Move(%q, %q", base.Name(), sourcePath, destPath)

	if !storagedriver.PathRegexp.MatchString(sourcePath) {
		return storagedriver.InvalidPathError{Path: sourcePath, DriverName: base.StorageDriver.Name()}
	} else if !storagedriver.PathRegexp.MatchString(destPath) {
		return storagedriver.InvalidPathError{Path: destPath, DriverName: base.StorageDriver.Name()}
	}

	start := time.Now()
	err := base.setDriverName(base.StorageDriver.Move(ctx, sourcePath, destPath))
	storageAction.WithValues(base.Name(), "Move").UpdateSince(start)
	return err
}
1345748
func (r *Render) move(from, to int) int {
	fromX, fromY := r.toPos(from)
	toX, toY := r.toPos(to)

	r.out.CursorUp(fromY - toY)
	r.out.CursorBackward(fromX - toX)
	return to
}
1007068
func (t Transformer) MoveTo(x, y float64) {
	u := x*t.Tr[0] + y*t.Tr[2] + t.Tr[4]
	v := x*t.Tr[1] + y*t.Tr[3] + t.Tr[5]
	t.Flattener.MoveTo(u, v)
}
120493
func (m *postgresMigrator) Up(migrations map[int]MigrationFunc) (int, error) {
	return m.UpTo(len(migrations), migrations)
}
590338
func (dc DemuxFlattener) MoveTo(x, y float64) {
	for _, flattener := range dc.Flatteners {
		flattener.MoveTo(x, y)
	}
}
345620
func (all *assetLruList) MoveToBack(alle *assetLruListElement) {
	if alle.list != all || all.root.prev == alle {
		return
	}
	// see comment in assetLruList.Remove about initialization of l
	all.insert(all.remove(alle), all.root.prev)
}
832412
func (s *Service) Up(ctx context.Context, options options.Up) error {
	containers, err := s.collectContainers(ctx)
	if err != nil {
		return err
	}

	var imageName = s.imageName()
	if len(containers) == 0 || !options.NoRecreate {
		if err = s.ensureImageExists(ctx, options.NoBuild, options.ForceBuild); err != nil {
			return err
		}
	}

	return s.up(ctx, imageName, true, options)
}
1369960
func (dc *Context) MoveTo(x, y float64) {
	if dc.hasCurrent {
		dc.fillPath.Add1(dc.start.Fixed())
	}
	x, y = dc.TransformPoint(x, y)
	p := Point{x, y}
	dc.strokePath.Start(p.Fixed())
	dc.fillPath.Start(p.Fixed())
	dc.start = p
	dc.current = p
	dc.hasCurrent = true
}
477771
func MoveTo(str string, x int, y int) (out string) {
	x, y = GetXY(x, y)

	return applyTransform(str, func(idx int, line string) string {
		return fmt.Sprintf("\033[%d;%dH%s", y+idx, x, line)
	})
}
1060463
func Move(ctx context.Context, s Store, src, des Object) error {
	// take the fast path, and use the store provided mover if available
	if src.StorageSource() == des.StorageSource() {
		if sm, ok := s.(StoreMove); ok {
			return sm.Move(ctx, src, des)
		}
	}

	if err := Copy(ctx, s, src, des); err != nil { // use Copy() to copy the files
		return err
	}

	if err := src.Delete(); err != nil { //delete the src, after des has been flushed/synced
		return err
	}

	return nil
}
1257293
func MoveresizeWindow(xu *xgbutil.XUtil, win xproto.Window,
	x, y, w, h int) error {

	return MoveresizeWindowExtra(xu, win, x, y, w, h, xproto.GravityBitForget,
		2, true, true)
}