// WalkDrop walks the Drop plan.
514502
func (m *JobExecutor) WalkDrop(p *plan.Drop) (Task, error) {
	root := m.NewTask(p)
	return root, root.Add(NewDrop(m.Ctx, p))
}
803653
func (t Term) IndexDrop(args ...interface{}) Term {
	return constructMethodTerm(t, "IndexDrop", p.Term_INDEX_DROP, args, map[string]interface{}{})
}
494697
func (f *File) walkFile(name string, file *ast.File) {
	Println("Checking file", name)
	ast.Walk(f, file)
}
369930
func (n *Label) Walk(v walker.Visitor) {
	if v.EnterNode(n) == false {
		return
	}

	if n.LabelName != nil {
		v.EnterChildNode("LabelName", n)
		n.LabelName.Walk(v)
		v.LeaveChildNode("LabelName", n)
	}

	v.LeaveNode(n)
}
720714
func WalkStmt(ctx *Context, stmt rel.SqlStatement, planner Planner) (Task, error) {
	var p Task
	base := NewPlanBase(false)
	switch st := stmt.(type) {
	case *rel.SqlSelect:
		p = &Select{Stmt: st, PlanBase: base, Ctx: ctx}
	case *rel.SqlInsert:
		p = &Insert{Stmt: st, PlanBase: base}
	case *rel.SqlUpsert:
		p = &Upsert{Stmt: st, PlanBase: base}
	case *rel.SqlUpdate:
		p = &Update{Stmt: st, PlanBase: base}
	case *rel.SqlDelete:
		p = &Delete{Stmt: st, PlanBase: base}
	case *rel.SqlShow:
		sel, err := RewriteShowAsSelect(st, ctx)
		if err != nil {
			return nil, err
		}
		ctx.Stmt = sel
		p = &Select{Stmt: sel, PlanBase: base, Ctx: ctx}
	case *rel.SqlDescribe:
		sel, err := RewriteDescribeAsSelect(st, ctx)
		if err != nil {
			return nil, err
		}
		ctx.Stmt = sel
		p = &Select{Stmt: sel, PlanBase: base}
	case *rel.PreparedStatement:
		p = &PreparedStatement{Stmt: st, PlanBase: base}
	case *rel.SqlCommand:
		p = &Command{Stmt: st, PlanBase: base, Ctx: ctx}
	case *rel.SqlCreate:
		p = &Create{Stmt: st, PlanBase: base, Ctx: ctx}
	case *rel.SqlDrop:
		p = &Drop{Stmt: st, PlanBase: base, Ctx: ctx}
	case *rel.SqlAlter:
		p = &Alter{Stmt: st, PlanBase: base, Ctx: ctx}
	default:
		panic(fmt.Sprintf("Not implemented for %T", stmt))
	}
	return p, p.Walk(planner)
}
767997
func (dht *IpfsDHT) walk(ctx context.Context, target peer.ID) (pstore.PeerInfo, error) {
	// TODO: Extract the query action (traversal logic?) inside FindPeer,
	// don't actually call through the FindPeer machinery, which can return
	// things out of the peer store etc.
	return dht.FindPeer(ctx, target)
}
1339422
func (m *InMemApplyer) Drop(s *Schema, v interface{}) error {

	// Find the type of operation being updated.
	switch v := v.(type) {
	case *Table:
		u.Debugf("%p:%s InfoSchema P:%p  dropping table %q from %v", s, s.Name, s.InfoSchema, v.Name, s.Tables())
		// s==v means schema is being dropped
		m.reg.mu.Lock()
		s.mu.Lock()
		s.dropTable(v)
		m.reg.schemas[s.Name] = s
		s.refreshSchemaUnlocked()
		s.mu.Unlock()
		m.reg.mu.Unlock()
	case *Schema:

		u.Debugf("%p:%s InfoSchema P:%p  dropping schema %q s==v?%v", s, s.Name, s.InfoSchema, v.Name, s == v)
		// s==v means schema is being dropped
		m.reg.mu.Lock()
		s.mu.Lock()

		delete(m.reg.schemas, s.Name)
		names := make([]string, 0, len(m.reg.schemaNames))
		for _, n := range m.reg.schemaNames {
			if s.Name != n {
				names = append(names, n)
			}
		}
		m.reg.schemaNames = names

		s.refreshSchemaUnlocked()
		s.mu.Unlock()
		m.reg.mu.Unlock()

	default:
		u.Errorf("invalid type %T", v)
		return fmt.Errorf("Could not find %T", v)
	}

	return nil
}
968153
func (cmd *CompactCommand) walk(db *bolt.DB, walkFn walkFunc) error {
	return db.View(func(tx *bolt.Tx) error {
		return tx.ForEach(func(name []byte, b *bolt.Bucket) error {
			return cmd.walkBucket(b, nil, name, nil, b.Sequence(), walkFn)
		})
	})
}
582475
func (n *ArgumentList) Walk(v walker.Visitor) {
	if v.EnterNode(n) == false {
		return
	}

	if n.Arguments != nil {
		v.EnterChildList("Arguments", n)
		for _, nn := range n.Arguments {
			if nn != nil {
				nn.Walk(v)
			}
		}
		v.LeaveChildList("Arguments", n)
	}

	v.LeaveNode(n)
}
565413
func (n *ArrayItem) Walk(v walker.Visitor) {
	if v.EnterNode(n) == false {
		return
	}

	if n.Key != nil {
		v.EnterChildNode("Key", n)
		n.Key.Walk(v)
		v.LeaveChildNode("Key", n)
	}

	if n.Val != nil {
		v.EnterChildNode("Val", n)
		n.Val.Walk(v)
		v.LeaveChildNode("Val", n)
	}

	v.LeaveNode(n)
}
742434
func (s *S3) Walk(ctx context.Context, path string, fn WalkFn) error {
	return fmt.Errorf("Walk not implemented for S3")
}
1153493
func Walk(v Visitor, n Node) {
	visitor{Visitor: v}.visit(nil, n)
}
270977
func (b *BinaryTree) Walk() []Comparable {
	walked := make([]Comparable, 0, b.size)
	return walkInOrder(b.root, walked)
}
451017
func (self *AccountingApi) SelfDrops() (int64, error) {
	if self.metrics == nil {
		return 0, errNoAccountingMetrics
	}
	return mSelfDrops.Count(), nil
}
936788
func (s *SeriesCollection) ApplyConcurrentDrops() {
	state := s.getState(false)
	if state == nil {
		return
	}

	length, j := s.Length(), 0
	for i := 0; i < length; i++ {
		if _, ok := state.index[i]; ok {
			s.Dropped++

			if i < len(s.Keys) {
				s.DroppedKeys = append(s.DroppedKeys, s.Keys[i])
			}

			continue
		}

		s.Copy(j, i)
		j++
	}
	s.Truncate(j)

	if s.Reason == "" {
		s.Reason = state.reason
	}

	// clear concurrent state
	atomic.StorePointer((*unsafe.Pointer)(unsafe.Pointer(&s.state)), nil)
}
969792
func (c *StashCollection) Drop(index int) error {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	ret := C.git_stash_drop(c.repo.ptr, C.size_t(index))
	runtime.KeepAlive(c)
	if ret < 0 {
		return MakeGitError(ret)
	}
	return nil
}
359370
func Walk(t *tree.Tree, ch, quit chan int) {
	walkImpl(t, ch, quit)
	close(ch)
}