Check if the bulk insertion buffer is full.

@return true if the bulk insertion buffer is full, false otherwise
3311
protected boolean isBulkInsertionBufferFull() {
        if (insertionBufferSize >= insertionBuffer.length) {
            return true;
        }
        double sizeAsDouble = size + insertionBufferSize;
        return Math.getExponent(sizeAsDouble) + 3 >= insertionBuffer.length;
    }
1106437
private boolean checkAvailable(){
        int i = 0;
        try{
            i = this.in.available();
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Current amount immediately available in buffers : " + i);
            }
        } catch (Exception e){
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "There was an IOException during the checkAvailable method : " + e);
            }
        }
        return ((i > 0) ? true : false);
    }
1316222
private boolean fillLast() throws IOException {
        int count;

        if (lastFilled == pageSize) {
            throw new IllegalStateException();
        }
        count = src.read(pages[lastNo], lastFilled, pageSize - lastFilled);
        if (count <= 0) {
            if (count == 0) {
                throw new IllegalStateException();
            }
            return false;
        }
        lastFilled += count;
        return true;
    }
513146
public static boolean contains(Saveable s) {
        for(BulkChange b=current(); b!=null; b=b.parent)
            if(b.saveable==s || b.saveable==ALL)
                return true;
        return false;
    }
880325
public boolean isValid() {
		if (this.cpuCores >= 0 && this.heapMemoryInMB >= 0 && this.directMemoryInMB >= 0 &&
				this.nativeMemoryInMB >= 0 && this.stateSizeInMB >= 0) {
			for (Resource resource : extendedResources.values()) {
				if (resource.getValue() < 0) {
					return false;
				}
			}
			return true;
		} else {
			return false;
		}
	}
1332727
@Override
    public boolean isEmpty() {
	final Segment<K, V>[] segments = this.segments;
	/*
	 * We keep track of per-segment modCounts to avoid ABA problems in which an element in one segment
	 * was added and in another removed during traversal, in which case the table was never actually
	 * empty at any point. Note the similar use of modCounts in the size() and containsValue() methods,
	 * which are the only other methods also susceptible to ABA problems.
	 */
	int[] mc = new int[segments.length];
	int mcsum = 0;
	for (int i = 0; i < segments.length; ++i) {
	    if (segments[i].count != 0) return false;
	    mcsum += mc[i] = segments[i].modCount;
	}
	// If mcsum happens to be zero, then we know we got a snapshot
	// before any modifications at all were made. This is
	// probably common enough to bother tracking.
	if (mcsum != 0) {
	    for (int i = 0; i < segments.length; ++i) {
		if (segments[i].count != 0 || mc[i] != segments[i].modCount) return false;
	    }
	}
	return true;
    }
773070
@Override
    public boolean hasNext()
    {
        if (checkOnFetchSize())
        {
            onCheckRelation();
            if (!checkOnEmptyResult())
            {
                scrollComplete = true;
                return false;
            }
            return true;
        }
        return false;
    }
726212
@VisibleForTesting
  synchronized boolean isMaxSizeSoftCapExceeded() {
    final boolean isMaxSizeSoftCapExceeded =
        (mUsed.mNumBytes + mFree.mNumBytes) > mPoolParams.maxSizeSoftCap;
    if (isMaxSizeSoftCapExceeded) {
      mPoolStatsTracker.onSoftCapReached();
    }
    return isMaxSizeSoftCapExceeded;
  }
364206
@Override
    public boolean isEmpty() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            JmfTr.entry(this, tc, "isEmpty");
        synchronized (getMessageLockArtefact()) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                JmfTr.exit(this, tc, "isEmpty");
            return super.isEmpty();
        }
    }
1094097
public final boolean isSpilling()
    {
        boolean spilling = false;
        // defect 208011 - all streams except STORE_NEVER can spill, not just store
        if (AbstractItem.STORE_NEVER != getTuple().getStorageStrategy())
        {
            // Defect 463642
            // Revert to using spill limits previously removed in SIB0112d.ms.2
            spilling = getListStatistics().isSpilling();
        }
        return spilling;
    }
813532
public boolean isEmpty() {
        return ((files == null) || files.isEmpty())
                && ((fileObjects == null) || fileObjects.isEmpty())
                && (classNames == null || classNames.isEmpty());
    }
158259
private boolean readRequiredBytes() {
    int totalBytesRead = 0;
    int deflatedBytesRead = 0;
    try {
      if (nextFrame == null) {
        nextFrame = new CompositeReadableBuffer();
      }

      // Read until the buffer contains all the required bytes.
      int missingBytes;
      while ((missingBytes = requiredLength - nextFrame.readableBytes()) > 0) {
        if (fullStreamDecompressor != null) {
          try {
            if (inflatedBuffer == null || inflatedIndex == inflatedBuffer.length) {
              inflatedBuffer = new byte[Math.min(missingBytes, MAX_BUFFER_SIZE)];
              inflatedIndex = 0;
            }
            int bytesToRead = Math.min(missingBytes, inflatedBuffer.length - inflatedIndex);
            int n = fullStreamDecompressor.inflateBytes(inflatedBuffer, inflatedIndex, bytesToRead);
            totalBytesRead += fullStreamDecompressor.getAndResetBytesConsumed();
            deflatedBytesRead += fullStreamDecompressor.getAndResetDeflatedBytesConsumed();
            if (n == 0) {
              // No more inflated data is available.
              return false;
            }
            nextFrame.addBuffer(ReadableBuffers.wrap(inflatedBuffer, inflatedIndex, n));
            inflatedIndex += n;
          } catch (IOException e) {
            throw new RuntimeException(e);
          } catch (DataFormatException e) {
            throw new RuntimeException(e);
          }
        } else {
          if (unprocessed.readableBytes() == 0) {
            // No more data is available.
            return false;
          }
          int toRead = Math.min(missingBytes, unprocessed.readableBytes());
          totalBytesRead += toRead;
          nextFrame.addBuffer(unprocessed.readBytes(toRead));
        }
      }
      return true;
    } finally {
      if (totalBytesRead > 0) {
        listener.bytesRead(totalBytesRead);
        if (state == State.BODY) {
          if (fullStreamDecompressor != null) {
            // With compressed streams, totalBytesRead can include gzip header and trailer metadata
            statsTraceCtx.inboundWireSize(deflatedBytesRead);
            inboundBodyWireSize += deflatedBytesRead;
          } else {
            statsTraceCtx.inboundWireSize(totalBytesRead);
            inboundBodyWireSize += totalBytesRead;
          }
        }
      }
    }
  }
898004
public boolean isFull()
	{
		return !itemStack.isEmpty() && itemStack.getCount() == Math.min(itemStack.getMaxStackSize(), getSlotStackLimit());
	}
99089
def is_full(self):
        """"""
        if self.length == 0.0:
            return False
        if len(self.bar) == 0:
            return False
        if self.current_beat >= self.length - 0.001:
            return True
        return False
1146692
public boolean isSingleMember() {
		final Address localAddress = getLocalAddress();
		if (localAddress != null) {
			final List<Address> clusterMembers = getClusterMembers();
			return clusterMembers.size() == 1;
		}
		else {
			return true;
		}
	}
1158490
public boolean isEmpty() {
        for (int i = 0; i < columns; i++) {
            if (cells[i] != null) {
                return false;
            }
        }
        return true;
    }
578516
public boolean bufferAckEnabled() {
    String bufSize = get(Names.CONNECTION_BUFFER_SIZE);
    return bufSize != null && Integer.parseInt(bufSize) > 0;
  }