// Do calls function f for each element of the tree, in order.
// The function should not change the structure of the tree underfoot.
430834
func (t *Tree) Do(f IterateFunc) {

	if f != nil && t.root != nil {
		d := &iterData{f}
		d.iterate(t.root)
	}
}
891291
func (r *queryTable) Do(f func(flux.ColReader) error) error {
	return r.DoArrow(func(cr flux.ArrowColReader) error {
		return f(arrow.ColReader(cr))
	})
}
842828
func (t *PairTree) Do(f PairIterateFunc) {
	t.ObjectTree.Do(func(v interface{}) bool { return f(v.(Pair)) })
}
891133
func (r *Request) Do() (*Response, error) {
	if r.dispatched {
		return nil, errors.New("gentleman: Request was already dispatched")
	}

	r.dispatched = true
	ctx := NewDispatcher(r).Dispatch()

	return buildResponse(ctx)
}
1028469
func Do(ctx Context, handlers Handlers) {
	if len(handlers) > 0 {
		ctx.SetHandlers(handlers)
		handlers[0](ctx)
	}
}
1258959
func (o *Once) Do(fn ...func()) bool {
	if !atomic.CompareAndSwapUint32((*uint32)(o), 0, 1) {
		return false
	}
	for _, f := range fn {
		if f != nil {
			f()
		}
	}
	return true
}
864576
func (m *mapReact) Do(fx func(SenderDetachCloser)) {
	m.ro.RLock()
	for ms := range m.ma {
		fx(ms)
	}
	m.ro.RUnlock()
}
856262
func (c *Client) Do(req *http.Request) (*http.Response, error) {
	return c.client.Do(req)
}
775867
func (c *Client) Do(ctx context.Context, r *Request) (*http.Response, error) {
	req, err := r.toHTTP(ctx, c.config)
	if err != nil {
		return nil, err
	}
	c.logRequest(req)
	resp, err := c.config.HTTPClient.Do(req)
	c.logResponse(resp)
	return resp, err
}
45862
func (j *Job) Do(jobFun interface{}, params ...interface{}) {
	typ := reflect.TypeOf(jobFun)
	if typ.Kind() != reflect.Func {
		panic("only function can be schedule into the job queue.")
	}

	fname := getFunctionName(jobFun)
	j.funcs[fname] = jobFun
	j.fparams[fname] = params
	j.jobFunc = fname
	//schedule the next run
	j.scheduleNextRun()
}
1295253
func (n *Node) do(c *Call) error {
	err := n.send(c.req)
	if err == nil {
		err = c.Wait()
	}
	return err
}
2470
func (r *queryTable) Do(f func(flux.ColReader) error) error {
	return f(r)
}
612085
func (c *Chan) Do(f func(Path)) {
	defer c.Close()
	for {
		x := <-(*c).c
		if x == nil {
			break
		}
		f(x)
	}
}
288769
func (s *sysSocket) do(f func()) error {
	// All operations handled by this function are assumed to only
	// read from s.done.
	s.mu.RLock()
	defer s.mu.RUnlock()

	if s.closed {
		return syscall.EBADF
	}

	s.g.run(f)
	return nil
}
342313
func Do(do DoFunc) Opt {
	return func(c *Client) Opt {
		old := c.do
		c.do = do
		return Do(old)
	}
}
492471
func (d *Do) Do(fn func()) {
	// Add job
	d.mq.Lock()
	d.queue = append(d.queue, fn)
	d.mq.Unlock()

	// Broadcast
	d.cond.L.Lock()
	d.cond.Broadcast()
	d.cond.L.Unlock()
}
1085077
func (s *Stepper) Do(f func(Path)) *Stepper {
	s.fs = append(s.fs, f)
	return s
}