// WithStageAfter registers a stage to run during compilation after
// the named stage.
558436
func (c *Compiler) WithStageAfter(after string, stage CompilerStage) *Compiler {
	c.after[after] = append(c.after[after], stage)
	return c
}
122006
func (c *Call) After(d time.Duration) *Call {
	c.lock()
	defer c.unlock()
	c.waitTime = d
	return c
}
1226698
func (s *CertificateValidity) SetNotAfter(v time.Time) *CertificateValidity {
	s.NotAfter = &v
	return s
}
108918
func (f *FSM) afterEventCallbacks(e *Event) {
	if fn, ok := f.callbacks[cKey{e.Event, callbackAfterEvent}]; ok {
		fn(e)
	}
	if fn, ok := f.callbacks[cKey{"", callbackAfterEvent}]; ok {
		fn(e)
	}
}
502566
func (s *SearchSource) TerminateAfter(terminateAfter int) *SearchSource {
	s.terminateAfter = &terminateAfter
	return s
}
725183
func (s *GetDifferencesInput) SetAfterCommitSpecifier(v string) *GetDifferencesInput {
	s.AfterCommitSpecifier = &v
	return s
}
403955
func (w *Writer) ensureStage(s indexWriterStage) error {
	if w.stage == s {
		return nil
	}
	if w.stage > s {
		return errors.Errorf("invalid stage %q, currently at %q", s, w.stage)
	}

	// Mark start of sections in table of contents.
	switch s {
	case idxStageSymbols:
		w.toc.Symbols = w.pos
	case idxStageSeries:
		w.toc.Series = w.pos

	case idxStageLabelIndex:
		w.toc.LabelIndices = w.pos

	case idxStagePostings:
		w.toc.Postings = w.pos

	case idxStageDone:
		w.toc.LabelIndicesTable = w.pos
		if err := w.writeOffsetTable(w.labelIndexes); err != nil {
			return err
		}
		w.toc.PostingsTable = w.pos
		if err := w.writeOffsetTable(w.postings); err != nil {
			return err
		}
		if err := w.writeTOC(); err != nil {
			return err
		}
	}

	w.stage = s
	return nil
}
371426
func (l *waiterList) InsertAfter(b, e *Entry) {
	a := waiterElementMapper{}.linkerFor(b).Next()
	waiterElementMapper{}.linkerFor(e).SetNext(a)
	waiterElementMapper{}.linkerFor(e).SetPrev(b)
	waiterElementMapper{}.linkerFor(b).SetNext(e)

	if a != nil {
		waiterElementMapper{}.linkerFor(a).SetPrev(e)
	} else {
		l.tail = e
	}
}
1133801
func (t *Module) SetAfter(action cli.ActionFunc) *Module {
	t.After = action
	return t
}
1013072
func (r *runner) doReturnStage(stg *jobsim.ReturnStage) error {
	retval := int64(0)
	if stg != nil {
		retval += stg.Retval
	}
	if r.state != nil {
		retval += r.state.Sum
	}

	_, err := r.dmc.FinishAttempt(r.c, &dm.FinishAttemptReq{
		Auth: r.auth,
		Data: executionResult(true, retval, google.TimeFromProto(stg.GetExpiration())),
	})
	if err != nil {
		logging.WithError(err).Warningf(r.c, "got error on FinishAttempt")
	}
	return err
}
418658
func (p *ExamplePlugin) AfterInit() error {
	resync.DefaultPlugin.DoResync()

	go p.etcdPublisher()

	go p.closeExample()

	return nil
}
105730
func (p *PushEvent) GetAfter() string {
	if p == nil || p.After == nil {
		return ""
	}
	return *p.After
}
1301524
func (rsc *ReplicaSetController) enqueueReplicaSetAfter(obj interface{}, after time.Duration) {
	key, err := controller.KeyFunc(obj)
	if err != nil {
		utilruntime.HandleError(fmt.Errorf("couldn't get key for object %+v: %v", obj, err))
		return
	}
	rsc.queue.AddAfter(key, after)
}
686512
func (l *List) InsertAfter(v *Node, mark *Element) *Element {
	if mark.list != l {
		return nil
	}
	// see comment in List.Remove about initialization of l
	return l.insertValue(v, mark)
}
261145
func (l *ItemList) MoveAfter(e, mark *ItemElement) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.insert(l.remove(e), mark)
}
383348
func (l *segmentList) InsertAfter(b, e *segment) {
	a := segmentElementMapper{}.linkerFor(b).Next()
	segmentElementMapper{}.linkerFor(e).SetNext(a)
	segmentElementMapper{}.linkerFor(e).SetPrev(b)
	segmentElementMapper{}.linkerFor(b).SetNext(e)

	if a != nil {
		segmentElementMapper{}.linkerFor(a).SetPrev(e)
	} else {
		l.tail = e
	}
}
630958
func (pt *PipelineTemplate) AddStage(stage *Stage) {
	pt.Stages = append(pt.Stages, stage)
}