// Push indicates an expected call of Push
511385
func (mr *MockNetworkEntityMockRecorder) Push(route, v interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockNetworkEntity)(nil).Push), route, v)
}
1247230
func (vc *ValueCounter) Push(acc telegraf.Accumulator) {
	for _, agg := range vc.cache {
		fields := map[string]interface{}{}

		for field, count := range agg.fieldCount {
			fields[field] = count
		}

		acc.AddFields(agg.name, fields, agg.tags)
	}
}
672427
func (s *SliceStack) Push(item interface{}) {
	s.size++
	s.backing = append(s.backing, item)
}
460151
func push(ctx context.Context, workingDir, upstream string, refs []string) error {
	args := append([]string{"push", upstream}, refs...)
	if err := execGitCmd(ctx, args, gitCmdConfig{dir: workingDir}); err != nil {
		return errors.Wrap(err, fmt.Sprintf("git push %s %s", upstream, refs))
	}
	return nil
}
1299156
func (self *Stack) Push(i ...Token) {
	self.Values = append(self.Values, i...)
}
1252893
func push(body map[string]interface{}) {
	if len(bodyChannel) < Buffer {
		waitGroup.Add(1)
		bodyChannel <- body
	} else {
		stderr("buffer full, dropping error on the floor")
	}
}
742364
func (g *Git) Push(branch string) *command.Model {
	return g.command("push", "-u", "origin", branch)
}
976590
func (s *Stack) Push(item interface{}) {
	s.l.Lock()
	defer s.l.Unlock()
	s.s = append(s.s, item)
}
1200125
func (s *scopeStack) push() {
	s.scopes = append(s.scopes, make(map[string]Value))
}
1247436
func (dc *Context) Push() {
	x := *dc
	dc.stack = append(dc.stack, &x)
}
290549
func (s *ParseStack) Push(ast AST) {
	s.container[s.top] = ast
	s.top++
}
66059
func (q *BytesQueue) Push(data []byte) (int, error) {
	dataLen := len(data)

	if q.availableSpaceAfterTail() < dataLen+headerEntrySize {
		if q.availableSpaceBeforeHead() >= dataLen+headerEntrySize {
			q.tail = leftMarginIndex
		} else if q.capacity+headerEntrySize+dataLen >= q.maxCapacity && q.maxCapacity > 0 {
			return -1, &queueError{"Full queue. Maximum size limit reached."}
		} else {
			q.allocateAdditionalMemory(dataLen + headerEntrySize)
		}
	}

	index := q.tail

	q.push(data, dataLen)

	return index, nil
}
151938
func (s *Stack) Push(value interface{}) {
	s.top = &Element{value: value, next: s.top}
	s.size++
}
382741
func (o OpCode) Pushes() int {
	if o >= PUSH1 && o <= PUSH32 {
		return int(o - PUSH1 + 1)
	}
	return 0
}
670442
func (s *Stack) Push(value interface{}) *Stack {
	s.values.PushBack(value)
	return s
}
1258389
func (p *Pipe) Push(procs ...Filter) *Pipe {
	for _, proc := range procs {
		if proc == nil {
			continue
		}

		err := make(chan error, 1)
		p.errors = append(p.errors, err)

		r, w := io.Pipe()

		go func(p Filter, r io.Reader, w *io.PipeWriter, err chan error) {
			err <- p(r, w)
			w.Close()
		}(proc, p.reader, w, err)

		p.reader = r
	}
	return p
}
1367511
func Push(listener func(*vecty.Event)) *vecty.EventListener {
	return &vecty.EventListener{Name: "push", Listener: listener}
}