Lines Matching defs:push
413 r.push('a')
424 r.push('â')
2084 fn push(b: &mut Bencher) {
2087 vec.push(0);
2108 match_vec.push(0);
2254 v.push((&mut rng).sample_iter(&Alphanumeric).take(n).collect());
2539 bheap.push(i);
2582 durations.push(after.duration_since(before));
5252 Match(a, b) => v.push(Match(a, b)),
5253 Reject(a, b) => v.push(Reject(a, b)),
5855 data.push('华');
5856 data.push('b'); // 1 byte
5857 data.push('¢'); // 2 byte
5858 data.push('€'); // 3 byte
5859 data.push('?'); // 4 byte
6281 s.push('0');
6288 s.push('0');
6567 tv.x.push(DropCounter { count: &mut count_x });
6568 tv.y.push(DropCounter { count: &mut count_y });
6591 v.push(i);
6598 v.push(16);
6637 v.push(1);
6639 v.push(2);
6641 v.push(3);
6655 w.push(i)
6662 w.push(i)
6949 v.push(());
6951 v.push(());
6958 v.push(());
6960 v.push(());
6966 v.push(());
6968 v.push(());
7117 vec2.push(i);
7127 vec2.push(i);
7137 vec2.push(i);
7147 vec2.push(i);
7158 vec2.push(i);
7169 vec2.push(i);
7180 vec2.push(i);
7960 v.push(i);
7967 v.push(16);
8205 v.push(13);
8213 v.push(1);
8214 v.push(2);
8220 v.push(1);
8329 v1.push(0);
8334 v1.push(0);
8339 v1.push(0);
8344 v1.push(0);
8357 v2.push(0);
8358 v1024.push([0; 1024]);
8364 v2.push(0);
8365 v1024.push([0; 1024]);
8371 v2.push(0);
8372 v1024.push([0; 1024]);
8378 v2.push(0);
8379 v1024.push([0; 1024]);
8385 v2.push(0);
8386 v1024.push([0; 1024]);
8398 v1025.push([0; 1025]);
8403 v1025.push([0; 1025]);
8408 v1025.push([0; 1025]);
8413 v1025.push([0; 1025]);
8418 v1025.push([0; 1025]);
8423 v1025.push([0; 1025]);
8428 v1025.push([0; 1025]);
8506 c1.v.push(Cell::new(None));
8507 c1.v.push(Cell::new(None));
8509 c2.v.push(Cell::new(None));
8510 c2.v.push(Cell::new(None));
8512 c3.v.push(Cell::new(None));
8513 c3.v.push(Cell::new(None));
8552 c1.refs.v.push(Cell::new(None));
8553 c1.refs.v.push(Cell::new(None));
8554 c2.refs.v.push(Cell::new(None));
8555 c2.refs.v.push(Cell::new(None));
8556 c3.refs.v.push(Cell::new(None));
8557 c3.refs.v.push(Cell::new(None));
8576 tester.push(());
9516 v.push(box 0);
9517 v.push(box 0);
9518 v.push(box 0);
9529 // Test on-stack push().
9531 v.push(1);
9535 // Test on-heap push().
9536 v.push(2);
10410 v.push(1);
10411 v.push(2);
10419 v.push(Rc::new(2));
10493 xs.push(i)
11798 // shift values 1 step to the right by pop, sub one, push
11817 // shift values 1 step to the right by pop, sub one, push
13449 heap.push(11);
13452 heap.push(5);
13455 heap.push(27);
13458 heap.push(3);
13461 heap.push(103);
13471 heap.push(box 11);
13474 heap.push(box 5);
13477 heap.push(box 27);
13480 heap.push(box 3);
13483 heap.push(box 103);
13608 a.push(1);
13609 a.push(2);
13617 a.push(1);
13618 a.push(2);
13620 b.push(3);
13621 b.push(4);
13622 b.push(5);
13748 // push the panicking item to the heap and catch the panic
13752 heap_ref.push(panic_item);
14694 /// This is ideal for implementing a bulk-push operation like `extend`.
15343 [a, '\0', _] => s.push(a),
15345 s.push(a);
15346 s.push(b);
15349 s.push(a);
15350 s.push(b);
15351 s.push(c);
15414 [a, '\0', _] => s.push(a),
15416 s.push(a);
15417 s.push(b);
15420 s.push(a);
15421 s.push(b);
15422 s.push(c);
16248 /// You can append a [`char`] to a `String` with the [`push`] method, and
16254 /// hello.push('w');
16258 /// [`push`]: String::push
16569 /// s.push('a');
16575 /// s.push('a');
16768 ret.push(c);
17046 /// s.push('a');
17047 /// s.push('b');
17093 /// s.push('a');
17094 /// s.push('b');
17242 /// s.push('1');
17243 /// s.push('2');
17244 /// s.push('3');
17250 pub fn push(&mut self, ch: char) {
17252 1 => self.vec.push(ch as u8),
17408 matches.push(m);
17644 /// v.push('a');
18012 iterator.for_each(move |c| self.push(c));
18017 self.push(c);
18034 self.push(c);
18696 self.push(c);
18982 /// clone_on_write.values.to_mut().push(3);
19699 //! gadgets.push(Rc::downgrade(&gadget1));
19700 //! gadgets.push(Rc::downgrade(&gadget2));
22727 result.push(sep.clone());
23066 runs.push(Run { start, len: end - start });
28997 v.push(i);
29225 // Try to push key-value pair into the current leaf node.
29227 cur_node.push(key, value);
29229 // No space left, go up and push there.
29237 // Found a node with space left, push here.
29246 // We are at the top, create a new root node and push there.
29259 open_node.push(key, value, right_tree);
29975 out_node.push(k.clone(), v.clone());
30006 out_node.push(k, v, subroot.unwrap_or_else(Root::new));
35038 stack.push((factor, dormant_r));
35371 root.push_internal_level().push(ins.kv.0, ins.kv.1, ins.right);
38535 pub fn push(&mut self, key: K, val: V) {
38550 pub fn push(&mut self, key: K, val: V, edge: Root<K, V>) {
39700 root1.borrow_mut().push(1, ());
40424 /// push onto the back in this manner, and iterating over `VecDeque` goes front
44336 //! heap.push(State { cost: 0, position: start });
44353 //! heap.push(next);
44450 /// heap.push(1);
44451 /// heap.push(5);
44452 /// heap.push(2);
44492 /// heap.push(Reverse(1));
44493 /// heap.push(Reverse(5));
44494 /// heap.push(Reverse(2));
44505 /// | [push] | [pop] | [peek]/[peek\_mut] |
44509 /// The value for `push` is an expected cost; the method documentation gives a
44512 /// [push]: BinaryHeap::push
44619 /// heap.push(4);
44638 /// heap.push(4);
44660 /// heap.push(1);
44661 /// heap.push(5);
44662 /// heap.push(2);
44719 /// heap.push(3);
44720 /// heap.push(5);
44721 /// heap.push(1);
44729 /// The expected cost of `push`, averaged over every possible ordering of
44736 /// sorted order and the amortized cost per push is *O*(log(*n*)) against a heap
44739 /// The worst case cost of a *single* call to `push` is *O*(*n*). The worst case
44743 pub fn push(&mut self, item: T) {
44745 self.data.push(item);
44762 /// heap.push(6);
44763 /// heap.push(3);
45122 /// heap.push(1);
45123 /// heap.push(5);
45124 /// heap.push(2);
45147 /// heap.push(4);
45174 /// heap.push(4);
45199 /// heap.push(4);
45322 /// heap.push(3);
45323 /// heap.push(5);
45324 /// heap.push(1);
45799 self.push(item);
45827 iterator.for_each(move |elem| self.push(elem));
45839 self.push(item);
46812 //! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and
46835 //! You can [`push`] values onto the end of a vector (which will grow the vector
46841 //! v.push(3);
46860 //! [`push`]: Vec::push
46943 /// vec.push(1);
46944 /// vec.push(2);
46967 /// vec.push(4);
46993 /// stack.push(1);
46994 /// stack.push(2);
46995 /// stack.push(3);
47134 /// [`push`] and [`insert`] will never (re)allocate if the reported capacity is
47135 /// sufficient. [`push`] and [`insert`] *will* (re)allocate if
47144 /// strategy is used will of course guarantee *O*(1) amortized [`push`].
47175 /// [`push`]: Vec::push
47236 /// vec.push(i);
47242 /// vec.push(11);
47375 /// vec.push(i);
47381 /// vec.push(11);
47435 /// v.push(1);
47436 /// v.push(2);
47437 /// v.push(3);
47527 /// v.push(-1);
47528 /// v.push(0);
47529 /// v.push(1);
48435 /// vec.push(3);
48440 pub fn push(&mut self, value: T) {
48612 /// v.push(1);
48685 /// This method uses a closure to create new values on every push. If
48801 /// you can use [`push`], [`extend`], [`extend_from_slice`],
48805 /// [`push`]: Vec::push
49287 self.push(item);
49305 // self.push(item);
49438 self.push(item);