Inserts the specified element at the tail of this queue.
As the queue is unbounded, this method will never return {@code false}.

@return {@code true} (as specified by {@link Queue#offer})
@throws NullPointerException if the specified element is null
495362
public boolean offer(E e) {
        final Node<E> newNode = newNode(Objects.requireNonNull(e));

        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            if (q == null) {
                // p is last node
                if (casNext(p, null, newNode)) {
                    // Successful CAS is the linearization point
                    // for e to become an element of this queue,
                    // and for newNode to become "live".
                    if (p != t) // hop two nodes at a time
                        casTail(t, newNode);  // Failure is OK.
                    return true;
                }
                // Lost CAS race to another thread; re-read next
            }
            else if (sentinel() == q)
                // We have fallen off list.  If tail is unchanged, it
                // will also be off-list, in which case we need to
                // jump to head, from which all live nodes are always
                // reachable.  Else the new tail is a better bet.
                p = (t != (t = tail)) ? t : head;
            else
                // Check for tail updates after two hops.
                p = (p != t && t != (t = tail)) ? t : q;
        }
    }
452105
public <T> boolean operator_add(/* @Nullable */ EList<? super T> list, /* @Nullable */ T element) {
		if(list != null && element != null)
			return list.add(element);
		else
			return false;
	}
899348
public void addToTail(QueueElement qe) {

		checkElementFree(qe);
		if (head == null) {
			head = qe;
			tail = qe;
			qe.queue = this;
		} else {
			qe.previous = tail;
			qe.next = null;
			tail.next = qe;
			tail = qe;
		}

		qe.queue = this;
		numElements++;

	}
641309
public boolean provide(float value)
    {
        FloatReference ref = new FloatReference(value);
        boolean res = queue.offer(ref);
        return res;
    }
698205
protected boolean addElem(final T element) {
    // validate element
    if (element == null) {
      throw new IllegalArgumentException("Null element is not supported.");
    }
    // find hashCode & index
    final int hashCode = element.hashCode();
    final int index = getIndex(hashCode);
    // return false if already present
    if (containsElem(index, element, hashCode)) {
      return false;
    }

    modification++;
    size++;

    // update bucket linked list
    LinkedElement<T> le = new LinkedElement<T>(element, hashCode);
    le.next = entries[index];
    entries[index] = le;
    return true;
  }
687364
public void accept(Supplier<PrimitiveIterator.OfInt> segments) {
      Supplier<PrimitiveIterator.OfInt> notifyThese;
      Object key = currentKey.get();
      if (key != null) {
         pendingSegments.put(key, segments);
         // We now try to go back and set current key to null
         if (currentKey.getAndSet(null) == null) {
            // If it was already null that means we returned our key via the iterator below
            // In this case they may or may not have seen the pendingSegments so if they didn't we have to
            // notify ourselves
            notifyThese = pendingSegments.remove(key);
         } else {
            // Means that the iteration will see this
            notifyThese = null;
         }
      } else {
         // This means that we got a set of segments that had no entries in them or the iterator
         // consumed all entries, so just notify right away
         notifyThese = segments;
      }
      if (notifyThese != null) {
         completionListener.accept(notifyThese);
      }
   }
49904
public boolean add(Element element) throws DocumentException {
        if (pause) {
            return false;
        }
        RtfBasicElement[] rtfElements = rtfDoc.getMapper().mapElement(element);
        if(rtfElements.length != 0) {
            for(int i = 0; i < rtfElements.length; i++) {
                if(rtfElements[i] != null) {
                    rtfDoc.add(rtfElements[i]);
                }
            }
            return true;
        } else {
            return false;
        }
    }
838560
@Override
    public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }
876259
public synchronized void addElement(T element) {
		List<T> origList = ref.get().list;
		boolean isPresent = origList.contains(element);
		if (isPresent) {
			return;
		}
		
		List<T> newList = new ArrayList<T>(origList);
		newList.add(element);
		
		swapWithList(newList);
	}
1321110
public synchronized void put(final Object o) {
        final Bucket b = new Bucket(o);

        if (tail != null) {
            tail.setNext(b);
            tail = b;
        } else {
            // queue was empty but has one element now
            head = tail = b;
        }
        count++;

        // notify any waiting tasks
        notify();
    }
75053
protected void offerAt(final int pos, O e) {
    if(pos == NO_VALUE) {
      // resize when needed
      if(size + 1 > queue.length) {
        resize(size + 1);
      }
      index.put(e, size);
      size++;
      heapifyUp(size - 1, e);
      heapModified();
      return;
    }
    assert (pos >= 0) : "Unexpected negative position.";
    assert (queue[pos].equals(e));
    // Did the value improve?
    if(comparator.compare(e, queue[pos]) >= 0) {
      return;
    }
    heapifyUp(pos, e);
    heapModified();
    return;
  }
953759
@Override
    public boolean add(IonValue child)
        throws ContainedValueException, NullPointerException
    {
        int index = _child_count;
        add(index, child);
        return true;
    }
1306419
private boolean addInstanceOfElement(HeaderElement root, HeaderElement elem) {
        // first add to the overall sequence list
        if (null == this.hdrSequence) {
            this.hdrSequence = elem;
            this.lastHdrInSequence = elem;
        } else {
            // find the end of the list and append this new element
            this.lastHdrInSequence.nextSequence = elem;
            elem.prevSequence = this.lastHdrInSequence;
            this.lastHdrInSequence = elem;
        }
        if (null == root) {
            return true;
        }
        HeaderElement prev = root;
        while (null != prev.nextInstance) {
            prev = prev.nextInstance;
        }
        prev.nextInstance = elem;
        return false;
    }
1262436
@Override
    public boolean offer(T t) {
        if (t == null) {
            throw new IllegalArgumentException();
        }

        boolean ret = false;
        synchronized (lock) {
            if (t instanceof QueueItem && ((QueueItem) t).isExpedited()) {

                if (numberOfUsedExpeditedSlots.get() < expeditedBuffer.length) {
                    expeditedInsert(t);
                    numberOfUsedExpeditedSlots.getAndIncrement();
                    ret = true;
                }
            } else {
                if (numberOfUsedSlots.get() < buffer.length) {
                    insert(t);
                    numberOfUsedSlots.getAndIncrement();
                    ret = true;
                }
            }
        }

        if (ret) {
            notifyGet_();
            return true;
        }

        return false;
    }
340721
public void addElement(Element element) {
		synchronized(lock) {
			checkNotFrozen();
			element.setPage(this);
			// elements
			if(elements == null) elements = new ArrayList<>();
			elements.add(element);
			// elementsById
			addToElementsById(element, false);
		}
	}
1277135
@Override
	public boolean add(E e) {
		if (capacity <= linkedBlockingQueue.size())
			linkedBlockingQueue.remove();
		return linkedBlockingQueue.add(e);
	}
195035
public boolean offer(T t) {
		// the current position will be just past the length bytes for this
		// item (length bytes will be 0 at the moment)
		int serializedLength = serializer.size();
		if (serializedLength == UNKNOWN_LENGTH) {
			return offerUnknownLength(t);
		} else {
			return offerKnownLength(t, serializedLength);
		}
	}