Adds a boolean
@param b Boolean
@throws IllegalStateException see {@link #checkBuilt()}
193284
public synchronized PacketBuilder withBoolean(final boolean b)
    {
        checkBuilt();
        try
        {
            dataOutputStream.writeBoolean(b);
        }
        catch (final IOException e)
        {
            logger.error("Unable to add boolean: {} : {}", e.getClass(), e.getMessage());
        }
        return this;
    }
325161
private boolean addToWebContainer() {
        if (!Thread.holdsLock(terminated)) {
            throw new IllegalStateException();
        }
        synchronized (addRemoveLock) {
            if (installer.installIntoWebContainer(this)) {
                setState(State.DEPLOYED);
                return true;
            } else {
                closeTracker();
                return false;
            }
        }
    }
326282
public void addAction(M element, boolean value)
    {
        actions.put(element, Boolean.valueOf(value));
    }
984739
public RowBuilder bool(String name)
  {
    ColumnBool column = new ColumnBool(_columns.size(), name, _offset);
    
    _offset += column.length();
    _columns.add(column);
    
    return this;
  }
408433
private static void addValue(CBuilder builder, ColumnDefinition def, ByteBuffer value) throws InvalidRequestException
    {
        if (value == null)
            throw new InvalidRequestException(String.format("Invalid null value in condition for column %s", def.name));
        builder.add(value);
    }
1150826
public void println(boolean b) throws IOException
    {    
        if(this._listener!= null &&  !checkIfCalledFromWLonError()){
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())    
                Tr.debug(tc, "non blocking println boolean , WriteListener enabled: " + this._listener);          

            _outHelper.println_NonBlocking(Boolean.toString(b));
        }
        else {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())    
                Tr.debug(tc, "println boolean");
            String value = Boolean.toString(b);
            synchronized(this) {
                    this.write(value.getBytes(), 0, value.length());
                    this.write(CRLF, 0, 2);
            }
        }
    }
198890
@Override
	public boolean add(final T element) {
		requireNonNull(element);

		boolean updated = false;
		final Iterator<T> iterator = _population.iterator();
		while (iterator.hasNext()) {
			final T existing = iterator.next();

			int cmp = _dominance.compare(element, existing);
			if (cmp > 0) {
				iterator.remove();
				updated = true;
			} else if (cmp < 0 || element.equals(existing)) {
				return updated;
			}
		}

		_population.add(element);
		return true;
	}
1213160
public void addBlock(Block block)
    {
        try {
            this.stack.getFirst().add(block);
        } catch (NoSuchElementException e) {
            throw new IllegalStateException("All container blocks are closed, too many calls to endBlockList().");
        }
    }
688437
protected boolean buildGetParams(StringBuilder sb, boolean isFirst) {
        BuilderListener listener = mListener;
        if (listener != null) {
            return listener.onBuildGetParams(sb, isFirst);
        } else {
            return isFirst;
        }
    }
404274
public synchronized PacketBuilder withByte(final byte b)
    {
        checkBuilt();
        try
        {
            dataOutputStream.writeByte(b);
        }
        catch (final IOException e)
        {
            logger.error("Unable to add byte: {} : {}", e.getClass(), e.getMessage());
        }
        return this;
    }
174436
public Parameters addParameter(String name, boolean b) {
    addParameter().setName(name).setValue(new BooleanType(b));
    return this;
  }
371080
protected void putBoolean(boolean data)
    {
        if (tc.isEntryEnabled()) Tr.entry(tc, "putBoolean", new Object[] { this, new Boolean(data)});

        if (tc.isDebugEnabled()) Tr.debug(tc, "Writing at position " + _buffer.position());
        _buffer.put(data ? TRUE : FALSE);

        if (tc.isEntryEnabled()) Tr.exit(tc, "putBoolean");
    }
819818
private boolean add(T e, boolean failWhenFull) {
        final Queue<T> queue = this.getOrCreateQueue(e);

        this.writeLock.lock();
        try {
            if (this.size == this.capacity) {
                if (failWhenFull) {
                    throw new IllegalStateException("Queue is at capacity: " + this.capacity);
                }

                return false;
            }

            final boolean added = queue.add(e);
            if (added) {
                this.size++;
                this.notEmpty.signal();
            }
            return added;
        } finally {
            this.writeLock.unlock();
        }
    }
978999
@Override
    public boolean add(final String s) {
        JsonPrimitive primitive = primitive(s);
        if (!contains(primitive)) {
            return add(primitive);
        } else {
            return false;
        }
    }
463574
public void add(VMTransitionBuilder b) {
        Map<VMState, VMTransitionBuilder> m = vmAMB2.get(b.getDestinationState());
        for (VMState src : b.getSourceStates()) {
            m.put(src, b);
        }
    }
235493
public static boolean[] add(final boolean[] a, final boolean element) {
        if (N.isNullOrEmpty(a)) {
            return Array.of(element);
        }

        final boolean[] newArray = new boolean[a.length + 1];

        copy(a, 0, newArray, 0, a.length);
        newArray[a.length] = element;

        return newArray;
    }
1206252
public static void checkState(boolean b, String errorMessageTemplate, double p) {
        if (!b) {
            throw new IllegalStateException(format(errorMessageTemplate, p));
        }
    }