// PushFront inserts a new assetLruListElement e with value v at the front of list l and returns e.
181733
func (all *assetLruList) PushFront(v *assetLruListEntry) *assetLruListElement {
	all.lazyInit()
	return all.insertValue(v, &all.root)
}
1240669
func (l *ItemList) Front() *ItemElement {
	if l.len == 0 {
		return nil
	}
	return l.root.next
}
359488
func (v *evalVisitor) pushExpr(expression *ast.Expression) {
	v.exprs = append(v.exprs, expression)
}
967780
func (d *domainClient) PushNodeByPathToFrontend(ctx context.Context, args *PushNodeByPathToFrontendArgs) (reply *PushNodeByPathToFrontendReply, err error) {
	reply = new(PushNodeByPathToFrontendReply)
	if args != nil {
		err = rpcc.Invoke(ctx, "DOM.pushNodeByPathToFrontend", args, reply, d.conn)
	} else {
		err = rpcc.Invoke(ctx, "DOM.pushNodeByPathToFrontend", nil, reply, d.conn)
	}
	if err != nil {
		err = &internal.OpError{Domain: "DOM", Op: "PushNodeByPathToFrontend", Err: err}
	}
	return
}
888148
func (d *dockerAPI) pushImage(name string) error {
	glog.V(4).Infof("docker push for image %q", name)

	ctx := context.Background()
	options := types.ImagePushOptions{}
	resp, err := d.client.ImagePush(ctx, name, options)
	if resp != nil {
		defer resp.Close()
	}
	if err != nil {
		return fmt.Errorf("error pushing image %q: %v", name, err)
	}

	scanner := bufio.NewScanner(resp)
	for scanner.Scan() {
		glog.Infof("docker pushing %s", scanner.Text())
	}

	if err := scanner.Err(); err != nil {
		return fmt.Errorf("error pushing image %q: %v", name, err)
	}

	return nil
}
529478
func (l *list) PushBack(v interface{}) *element {
	return l.insertValue(v, l.root.prev)
}
626041
func (ctx *Context) PushGlobalInterface(name string, v interface{}) error {
	return ctx.pushGlobalValue(name, reflect.ValueOf(v))
}
254910
func (s *Sprocket) PushBackAlterExtension(ext, alterExt string) {
	s.getOrCreateExtensionInfo(ext).AlterExts.PushBackUniq(alterExt)
}
985949
func (ctx *Context) PushType(s interface{}) int {
	return ctx.PushGoFunction(func() {
		value := reflect.New(reflect.TypeOf(s))
		ctx.PushProxy(value.Interface())
	})
}
1183001
func (alle *assetLruListElement) Prev() *assetLruListElement {
	if p := alle.prev; alle.list != nil && p != &alle.list.root {
		return p
	}
	return nil
}
365866
func (all *assetLruList) MoveBefore(alle, mark *assetLruListElement) {
	if alle.list != all || alle == mark || mark.list != all {
		return
	}
	all.insert(all.remove(alle), mark.prev)
}
588840
func (l *list) PushFrontList(other *list) {
	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
		l.insertValue(e.Value, &l.root)
	}
}
122039
func (L *State) PushValue(index int) {
	C.lua_pushvalue(L.s, C.int(index))
}
376674
func (e *FSTEnum) pushFirst() (err error) {
	arc := e.arcs[e.upto]
	assert(arc != nil)

	for {
		e.output[e.upto] = e.fst.outputs.Add(e.output[e.upto-1], arc.Output)
		if arc.Label == FST_END_LABEL {
			// final node
			break
		}
		// fmt.Printf("  pushFirst label=%c upto=%v output=%v\n",
		// 	rune(arc.Label), e.upto, e.fst.outputs.outputToString(e.output[e.upto]))
		e.spi.setCurrentLabel(arc.Label)
		e.incr()

		nextArc := e.Arc(e.upto)
		if _, err = e.fst.readFirstTargetArc(arc, nextArc, e.fstReader); err != nil {
			return
		}
		arc = nextArc
	}
	return nil
}
268177
func (l *ItemList) PushFrontList(other *ItemList) {
	l.lazyInit()
	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
		l.insertValue(e.Value, &l.root)
	}
}
978532
func (g *MultiLineString) Push(ls *LineString) error {
	if ls.layout != g.layout {
		return ErrLayoutMismatch{Got: ls.layout, Want: g.layout}
	}
	g.flatCoords = append(g.flatCoords, ls.flatCoords...)
	g.ends = append(g.ends, len(g.flatCoords))
	return nil
}
887106
func (l *CList) PushBack(v interface{}) *CElement {
	l.mtx.Lock()

	// Construct a new element
	e := &CElement{
		prev:       nil,
		prevWg:     waitGroup1(),
		prevWaitCh: make(chan struct{}),
		next:       nil,
		nextWg:     waitGroup1(),
		nextWaitCh: make(chan struct{}),
		removed:    false,
		Value:      v,
	}

	// Release waiters on FrontWait/BackWait maybe
	if l.len == 0 {
		l.wg.Done()
		close(l.waitCh)
	}
	if l.len >= l.maxLen {
		panic(fmt.Sprintf("clist: maximum length list reached %d", l.maxLen))
	}
	l.len++

	// Modify the tail
	if l.tail == nil {
		l.head = e
		l.tail = e
	} else {
		e.SetPrev(l.tail) // We must init e first.
		l.tail.SetNext(e) // This will make e accessible.
		l.tail = e        // Update the list.
	}
	l.mtx.Unlock()
	return e
}