// doChildren performs the passed function for all children.
349787
func (n *node) doChildren(f func(cn *node) error) error {
	for _, child := range n.children {
		if err := f(child); err != nil {
			return errors.Annotate(err, ErrNodeDoChildren, errorMessages)
		}
	}
	return nil
}
366422
func (i *Handle) doCmdWithoutAttr(cmd uint8) ([][]byte, error) {
	req := newIPVSRequest(cmd)
	req.Seq = atomic.AddUint32(&i.seq, 1)
	return execute(i.sock, req, 0)
}
1205850
func (o *Opts) DocAfter(target, newid, template string) *Opts {
	return o.docOffset(1, target, newid, template)
}
57773
func (r *RewriteOptions) treeFn() TreeCallbackFn {
	if r.TreeCallbackFn == nil {
		return noopTreeFn
	}
	return r.TreeCallbackFn
}
1146052
func (d *domainClient) EvaluateOnCallFrame(ctx context.Context, args *EvaluateOnCallFrameArgs) (reply *EvaluateOnCallFrameReply, err error) {
	reply = new(EvaluateOnCallFrameReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "Debugger.evaluateOnCallFrame", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "Debugger.evaluateOnCallFrame", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "Debugger", Op: "EvaluateOnCallFrame", Err: err}
	}
	return
}
748036
func (r *RewriteOptions) treePreFn() TreePreCallbackFn {
	if r.TreePreCallbackFn == nil {
		return noopTreePreFn
	}
	return r.TreePreCallbackFn
}
1358514
func (obj *Doc) ExpandExpression(ctx context.Context, expression string) (string, error) {
	result := &struct {
		ExpandedExpression string	`json:"qExpandedExpression"`
	} {}
	err := obj.rpc(ctx, "ExpandExpression", result, expression)
	return result.ExpandedExpression, err 
}
406518
func (fs *KBFSOpsStandard) GetDirChildren(ctx context.Context, dir Node) (
	map[string]data.EntryInfo, error) {
	timeTrackerDone := fs.longOperationDebugDumper.Begin(ctx)
	defer timeTrackerDone()

	ops := fs.getOpsByNode(ctx, dir)
	return ops.GetDirChildren(ctx, dir)
}
1019225
func Docf(raw string, args ...interface{}) string {
	return fmt.Sprintf(Doc(raw), args...)
}
1060860
func (entity *AEBackupInformationKindTypeInfo) FetchChildren(c context.Context) error {
	entityTypeInfo := &AEBackupEntityTypeInfo{}
	err := json.Unmarshal([]byte(entity.EntityTypeInfo), entityTypeInfo)
	if err != nil {
		g := goon.FromContext(c)
		key := g.Key(entity)
		log.Infof(c, "on AEBackupInformationKindTypeInfo#FetchChildren json.Unmarshal, key: %s, %s", key.String(), entity.EntityTypeInfo)
		return err
	}
	entity.EntityTypeInfoJSON = entityTypeInfo

	return nil
}
500599
func (v *evalVisitor) evalFieldFunc(name string, funcVal reflect.Value, exprRoot bool) reflect.Value {
	ensureValidHelper(name, funcVal)

	var options *Options
	if exprRoot {
		// create function arg with all params/hash
		expr := v.curExpr()
		options = v.helperOptions(expr)

		// ok, that expression was a function call
		v.exprFunc[expr] = true
	} else {
		// we are not at root of expression, so we are a parameter... and we don't like
		// infinite loops caused by trying to parse ourself forever
		options = newEmptyOptions(v)
	}

	return v.callFunc(name, funcVal, options)
}
287883
func (ch *channel) Extended(code uint32) io.ReadWriter {
	if !ch.decided {
		return nil
	}
	return &extChannel{code, ch}
}
941732
func (addr *Address) DocID() string {
	return addr.st.docID(addr.doc.DocID)
}
464550
func eventAddHandleFunc(fd C.int, event C.int, callback uintptr, opaque uintptr, free uintptr) C.int {
	if eventLoopImpl == nil {
		panic("Event loop impl is missing")
	}

	cbinfo := &EventHandleCallbackInfo{
		callback: callback,
		opaque:   opaque,
		free:     free,
	}

	return C.int(eventLoopImpl.AddHandleFunc(int(fd), EventHandleType(event), cbinfo))
}
327939
func (dev *LinkLayerDevice) DocID() string {
	return dev.st.docID(dev.doc.DocID)
}
1330197
func childAddrOf(child, parent string) bool {
	cs := strings.Split(child, ".")
	ps := strings.Split(parent, ".")
	if len(ps) > len(cs) {
		return false
	}
	return reflect.DeepEqual(ps, cs[:len(ps)])
}
298576
func NewRefPaperDoc(DocId string) *RefPaperDoc {
	s := new(RefPaperDoc)
	s.DocId = DocId
	return s
}