// InsertAfter inserts e after b.
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
	}
}
437670
func (a *CompositeAggregation) AggregateAfter(after map[string]interface{}) *CompositeAggregation {
	a.after = after
	return a
}
931271
func (g *MetagameServer) simpleAfter(ctx context.Context, resp interface{}, err error) (interface{}, error) {
	logger := pitaya.GetDefaultLoggerFromCtx(ctx)
	logger.Infof("Simple After exec - response: %v , error: %v", resp, err)

	return resp, err
}
1020669
func (all *assetLruList) InsertAfter(v *assetLruListEntry, mark *assetLruListElement) *assetLruListElement {
	if mark.list != all {
		return nil
	}
	// see comment in assetLruList.Remove about initialization of l
	return all.insertValue(v, mark)
}
382040
func (l *ItemList) insert(e, at *ItemElement) *ItemElement {
	n := at.next
	at.next = e
	e.prev = at
	e.next = n
	n.prev = e
	e.list = l
	l.len++
	return e
}
277513
func (c *TCP) PublishAfter(tags []string, data string, delay time.Duration) error {
	go func() {
		<-time.After(delay)
		c.Publish(tags, data)
	}()
	return nil
}
971804
func (l *reassemblerList) InsertAfter(b, e *reassembler) {
	a := reassemblerElementMapper{}.linkerFor(b).Next()
	reassemblerElementMapper{}.linkerFor(e).SetNext(a)
	reassemblerElementMapper{}.linkerFor(e).SetPrev(b)
	reassemblerElementMapper{}.linkerFor(b).SetNext(e)

	if a != nil {
		reassemblerElementMapper{}.linkerFor(a).SetPrev(e)
	} else {
		l.tail = e
	}
}
578221
func (s *SearchService) TerminateAfter(terminateAfter int) *SearchService {
	s.searchSource = s.searchSource.TerminateAfter(terminateAfter)
	return s
}
824439
func (g *Group) Insert(e *GroupExpr) bool {
	if g.Exists(e) {
		return false
	}

	operand := GetOperand(e.ExprNode)
	var newEquiv *list.Element
	mark, hasMark := g.FirstExpr[operand]
	if hasMark {
		newEquiv = g.Equivalents.InsertAfter(e, mark)
	} else {
		newEquiv = g.Equivalents.PushBack(e)
		g.FirstExpr[operand] = newEquiv
	}
	g.Fingerprints[e.FingerPrint()] = newEquiv
	return true
}
1083790
func (l *PacketList) MoveAfter(e, mark *PacketElement) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.insert(l.remove(e), mark)
}
180090
func (l *ByteIntervalList) MoveAfter(e, mark *ByteIntervalElement) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.insert(l.remove(e), mark)
}
72340
func Nextafter(x, y int) (r int) {
	return engoimath.Nextafter(x, y)
}
1133801
func (t *Module) SetAfter(action cli.ActionFunc) *Module {
	t.After = action
	return t
}
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
	}
}
434257
func PublishAfter(tags []string, data string, delay time.Duration) error {
	go func() {
		<-time.After(delay)
		if err := Publish(tags, data); err != nil {
			// log this error and continue?
			lumber.Error("Failed to PublishAfter - %s", err.Error())
		}
	}()

	return nil
}
400205
func (mq *MockQuery) After(d time.Duration) *MockQuery {
	return mq.WaitUntil(time.After(d))
}
184661
func (tm *Timer) TriggerAfter(duration time.Duration) {
	go func() {
		time.Sleep(duration)
		tm.Trigger()
	}()
}