//OverrideAfter allows calling Then with an action after the current index
//that is you want to listen to the action at this index to fullfill the
//next index
170862
func (a *ActDepend) OverrideAfter(index int, fx func(b interface{}, a ActionInterface)) ActionInterface {
	ind, ok := a.correctIndex(index)

	if !ok {
		return a
	}

	ax := a.waiters[ind]
	var dx ActionInterface
	var nx = ind + 1

	if _, ok := a.states[nx]; ok {
		a.states[nx] = true
	}

	if nx >= a.Size() {
		return ax.Then(fx)
	}

	dx = a.waiters[nx]

	return ax.UseThen(fx, dx)

}
8497
func (_m *DFS) Override(newImage string, oldImage string) error {
	ret := _m.Called(newImage, oldImage)

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string) error); ok {
		r0 = rf(newImage, oldImage)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
713903
func (dfs *DistributedFilesystem) Override(newimg, oldimg string) error {

	// make sure the old image exists
	oldImage, err := dfs.index.FindImage(oldimg)
	if err != nil {
		glog.Errorf("Could not find image %s in registry: %s", oldimg, err)
		return err
	}

	// make sure the new image exists
	newImage, err := dfs.docker.FindImage(newimg)
	if err != nil {
		glog.Errorf("Could not find replacement image %s: %s", newimg, err)
		return err
	}

	// push the image into the registry
	hash, err := dfs.docker.GetImageHash(newImage.ID)
	if err != nil {
		glog.Errorf("Could not get hash for image %s: %s", newimg, err)
		return err
	}

	if err := dfs.index.PushImage(oldImage.String(), newImage.ID, hash); err != nil {
		glog.Errorf("Could not replace image %s with %s (%s): %s", oldImage, newimg, newImage.ID, err)
		return err
	}
	return nil
}
484203
func (s *CreateReceiptRuleInput) SetAfter(v string) *CreateReceiptRuleInput {
	s.After = &v
	return s
}
181649
func PublisherAfter(after ...PublisherResponseFunc) PublisherOption {
	return func(p *Publisher) { p.after = append(p.after, after...) }
}
1345244
func (s *DescribeSigningJobOutput) SetOverrides(v *SigningPlatformOverrides) *DescribeSigningJobOutput {
	s.Overrides = v
	return s
}
666258
func ClientAfter(after ...ClientResponseFunc) ClientOption {
	return func(c *Client) { c.after = append(c.after, after...) }
}
352886
func (l *icmpPacketList) InsertAfter(b, e *icmpPacket) {
	a := icmpPacketElementMapper{}.linkerFor(b).Next()
	icmpPacketElementMapper{}.linkerFor(e).SetNext(a)
	icmpPacketElementMapper{}.linkerFor(e).SetPrev(b)
	icmpPacketElementMapper{}.linkerFor(b).SetNext(e)

	if a != nil {
		icmpPacketElementMapper{}.linkerFor(a).SetPrev(e)
	} else {
		l.tail = e
	}
}
7684
func (l *List) InsertAfter(b, e Element) {
	a := ElementMapper{}.linkerFor(b).Next()
	ElementMapper{}.linkerFor(e).SetNext(a)
	ElementMapper{}.linkerFor(e).SetPrev(b)
	ElementMapper{}.linkerFor(b).SetNext(e)

	if a != nil {
		ElementMapper{}.linkerFor(a).SetPrev(e)
	} else {
		l.tail = e
	}
}
739744
func (transition *EventTransition) After(fc func(value interface{}, tx *gorm.DB) error) *EventTransition {
	transition.afters = append(transition.afters, fc)
	return transition
}
523211
func (s *ListNotebookInstancesInput) SetLastModifiedTimeAfter(v time.Time) *ListNotebookInstancesInput {
	s.LastModifiedTimeAfter = &v
	return s
}
188853
func (s *BulkProcessorService) After(fn BulkAfterFunc) *BulkProcessorService {
	s.afterFn = fn
	return s
}
909907
func (all *assetLruList) MoveAfter(alle, mark *assetLruListElement) {
	if alle.list != all || alle == mark || mark.list != all {
		return
	}
	all.insert(all.remove(alle), mark)
}
723502
func (q *delayingType) AddAfter(item interface{}, duration time.Duration) {
	// don't add if we're already shutting down
	if q.ShuttingDown() {
		return
	}

	q.metrics.retry()
	q.deprecatedMetrics.retry()

	// immediately add things with no delay
	if duration <= 0 {
		q.Add(item)
		return
	}

	select {
	case <-q.stopCh:
		// unblock if ShutDown() is called
	case q.waitingForAddCh <- &waitFor{data: item, readyAt: q.clock.Now().Add(duration)}:
	}
}
1088849
func (s *ActivatedRule) SetOverrideAction(v *WafOverrideAction) *ActivatedRule {
	s.OverrideAction = v
	return s
}
530717
func (c *Client) overrideHeader(req *http.Request) {
	if c.RequestHeader != nil {
		for k := range *c.RequestHeader {
			req.Header.Set(k, c.RequestHeader.Get(k))
		}
	}
}
1041354
func OverrideDial(dialFN func(ctx context.Context, net string, addr string) (net.Conn, error)) {
	dial.Store(dialFN)
}