add an element to the stack

@param n - the element to add
@return boolean - true if the operation succeeded
978195
@Override
    public boolean push(final N n) {
        if(stackTop < size) {
            stack[(stackTop++) & mask] = n;
            return true;
        }
        return false;

    }
524107
public <T> boolean operator_add(/* @Nullable */ EList<? super T> list, /* @Nullable */ Iterable<? extends T> elements) {
		boolean result = false;
		if(list != null && elements != null)
			for(T element: elements) 
				result |= operator_add(list, element);
		return result;
	}
265629
public void insertNode(Node n, int pos)
  {

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    insertElementAt(n, pos);
  }
341166
public boolean add(BtrpElement el) {
        switch (el.type()) {
            case VM:
                if (!this.vms.add((VM) el.getElement())) {
                    return false;
                }
                break;
            case NODE:
                if (!this.nodes.add((Node) el.getElement())) {
                    return false;
                }
                break;
            default:
                return false;
        }
        return true;

    }
1118101
public boolean add(E e) {
		hashCodeUpToDate = false;
		ensureCapacityInternal(size + 1); // Increments modCount!!
		elementData[size++] = e;
		return true;
	}
1119388
public boolean add(Object element) {

        last.next = new Node(element, null);
        last      = last.next;

        elementCount++;

        return true;
    }
48780
public void addNode(Node n)
  {

    if (!m_mutable)
      throw new RuntimeException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_NOT_MUTABLE, null)); //"This NodeSet is not mutable!");

    this.addElement(n);
  }
564634
public boolean add(E e) {
        typeCheck(e);

        long oldElements = elements;
        elements |= (1L << ((Enum<?>)e).ordinal());
        return elements != oldElements;
    }
92052
public void addEdge(N a, N b)
    {
        if( !containsBoth(a, b) )
            return;//Cant add nodes to things that doing exist
        nodes.get(a).getOutgoing().add(b);
        nodes.get(b).getIncoming().add(a);
    }
300454
@Override
   public boolean add(T element)
   {
      if (size < elementData.length) {
         elementData[size++] = element;
      }
      else {
         // overflow-conscious code
         final int oldCapacity = elementData.length;
         final int newCapacity = oldCapacity << 1;
         @SuppressWarnings("unchecked")
         final T[] newElementData = (T[]) Array.newInstance(clazz, newCapacity);
         System.arraycopy(elementData, 0, newElementData, 0, oldCapacity);
         newElementData[size++] = element;
         elementData = newElementData;
      }

      return true;
   }
351495
public void add(Number number) {
    elements.add(number == null ? JsonNull.INSTANCE : new JsonPrimitive(number));
  }
1053631
def add_int(self, n):
        
        self.packet.write(struct.pack('>I', n))
        return self
123536
public boolean add(E e) {
        typeCheck(e);

        int eOrdinal = e.ordinal();
        int eWordNum = eOrdinal >>> 6;

        long oldElements = elements[eWordNum];
        elements[eWordNum] |= (1L << eOrdinal);
        boolean result = (elements[eWordNum] != oldElements);
        if (result)
            size++;
        return result;
    }
596097
public boolean add(Object o) {
        if (o instanceof GroupCmdReply == false) {
            return true;
        }
        GroupCmdReply gcr = (GroupCmdReply)o;
        if (gcr.has_failed) {
            has_failed = true;
        }
        return super.add(o);
    }
1337375
@Override
    public boolean add(T elem) {
        /* First, check if we're completely out of space.  If so, do a resize
         * to ensure we do indeed have room.
         */
        if (size() == mArrays.length * mArrays.length)
            grow();

        /* Compute the (arr, index) pair for the next position.  The next
         * position is at the location indicated by size(), but we know that
         * space exists from the previous call.
         */
        final int offset = computeOffset(size());
        final int index = computeIndex(size());

        /* Check if an array exists here.  If not, make one up. */
        if (mArrays[offset] == null)
            mArrays[offset] = (T[]) new Object[mArrays.length];

        /* Write the element to its location. */
        mArrays[offset][index] = elem;

        /* Update the element count. */
        ++mSize;

        /* Per the Collections contract, return true to signal a successful
         * add.
         */
        return true;
    }
605429
public void add(long n)
    {
        int index = Arrays.binarySearch(bucketOffsets, n);
        if (index < 0)
        {
            // inexact match, take the first bucket higher than n
            index = -index - 1;
        }
        // else exact match; we're good
        buckets.incrementAndGet(index);
    }
600583
public void insert(int n) {
    this.indices.growTo(n + 1, -1);
    assert !this.inHeap(n);
    this.indices.set(n, this.heap.size());
    this.heap.push(n);
    this.percolateUp(this.indices.get(n));
  }