push(object)
 enq(object)
 <<(object)

 Pushes the given +object+ to the queue.
542504
def push(object)
      raise ClosedQueueError, "queue closed" if @close
      if (waiter = @waiters.shift)
        future = LightIO::Future.new
        LightIO::IOloop.current.add_callback {
          waiter.transfer(object)
          future.transfer
        }
        future.value
      else
        @queue << object
      end
      self
    end
1062900
public void enqueue(T item) {
        queue[head] = item;
        head++;
        size++;
        if (head == queue.length) head = 0;
    }
1016554
def enqueue(self, item_type, item):
        """"""

        with self.enlock:
            self.queue[item_type].append(item)
194275
def enqueue(self, pipeline):
        
        copied = Pipeline().append(pipeline)
        copied.group = self
        self._queue.put(copied)
1151369
def push(self, record, shard):
        
        heapq.heappush(self.heap, heap_item(self.clock, record, shard))
584850
function push(item, a)
{
	var pushed = push_(item, a);
	if (pushed !== null)
	{
		return pushed;
	}

	var newTree = create(item, a.height);
	return siblise(a, newTree);
}
278154
private void pushRun(int runBase, int runLen) {
        this.runBase[stackSize] = runBase;
        this.runLen[stackSize] = runLen;
        stackSize++;
    }
92732
function pushState(stack, type, instance) {
  stack.type = type;
  stack.children = [];
  stack.instance = instance || stack;
}
720698
def push(self, value):
        
        if self.closed and not self.allow_add_after_close:
            Log.error("Do not push to closed queue")

        with self.lock:
            self._wait_for_queue_space()
            if not self.closed:
                self.queue.appendleft(value)
        return self
61778
def PushItem(self, item, block=True):
    
    try:
      self._queue.put(item, block=block)
    except Queue.Full as exception:
      raise errors.QueueFull(exception)
1371573
public static void pushContext() {
        RpcInternalContext context = LOCAL.get();
        if (context != null) {
            Deque<RpcInternalContext> deque = DEQUE_LOCAL.get();
            if (deque == null) {
                deque = new ArrayDeque<RpcInternalContext>();
                DEQUE_LOCAL.set(deque);
            }
            deque.push(context);
            LOCAL.set(null);
        }
    }
1025635
def queue(self, value):
		
		if not isinstance(value, Queue):
			raise TypeError("queue is not a Queue object")
		self._queue = value
137765
def push(self, proxy, key, attribute, relation_operation):
        
        node = TraversalPathNode(proxy, key, attribute, relation_operation)
        self.nodes.append(node)
        self.__keys.add(key)
437942
@Deprecated
  public void push(Collector collector, String job, String instance) throws IOException {
    push(collector, job, Collections.singletonMap("instance", instance));
  }
1109411
function visitor(node, index, parent) {
    if (parent && queue.indexOf(parent) === -1) {
      queue.push(parent)
      one(parent)
    }
  }
520244
def push(j)
      raise "invalid work" if j == nil
      j.job_id = IDManager.get if j.job_id == nil
      j.group = self
      @queue.push(j)
      @jobs_by_id[j.job_id] = j
    end
1355078
final void push(UniCompletion<?,?> c) {
        if (c != null) {
            while (result == null && !tryPushStack(c))
                lazySetNext(c, null); // clear on failure
        }
    }