If any of the non-counter fields are null, return true.
@param iAreaDesc
@return
556633
public boolean isNull(int iAreaDesc, boolean bIncludeTempFields)
    {
        for (int i = 0; i < this.getKeyFields(false, bIncludeTempFields); i++)
        {
            if (this.getField(i) != this.getRecord().getCounterField())
                if (this.getKeyField(i).getField(iAreaDesc).isNull())
                    return true;    // Is null
        }
        return false;   // is not null
    }
213476
protected boolean hasReadElfTag(String tag) {
        String tagValue = getReadElfTag(tag);
        return (tagValue != null && !tagValue.isEmpty());
    }
231220
@Override
	public boolean hasNext()
		throws ArticleReaderException
	{

		if (super.hasNext()) {

			if (lastTaskCompleted) {
				this.taskStartPosition = this.getBytePosition();
				this.processingTimeRead = 0;
				this.readRevisionCounter = 0;
				this.lastTaskCompleted = false;
			}

			return true;
		}
		return false;
	}
404192
Nullness standardFieldNullness(
      ClassAndField accessed, @Nullable AccessPath path, AccessPathValues<Nullness> store) {
    // First, check the store for a dataflow-computed nullness value and return it if it exists
    // Otherwise, check for nullness annotations on the field's symbol (including type annotations)
    // If there are none, check for nullness annotations on generic type bounds, if any
    // If there are none, fall back to the defaultAssumption

    Nullness dataflowResult = (path == null) ? BOTTOM : store.valueOfAccessPath(path, BOTTOM);
    if (dataflowResult != BOTTOM) {
      return dataflowResult;
    }

    Optional<Nullness> declaredNullness = NullnessAnnotations.fromAnnotationsOn(accessed.symbol);
    return declaredNullness.orElseGet(
        () -> NullnessAnnotations.getUpperBound(accessed.symbol.type).orElse(defaultAssumption));
  }
282937
public boolean checkObsolete(IGraphStore store, boolean isReorg, int lineNo, String fileName) {
        if (type == RecordType.T) {
            // Transaction boundaries are obsolete during reorg 
            return isReorg;
        } else if (type == RecordType.L) {
            // A log is always obsolete
            return false;
        } else if ((type != RecordType.V) && (type != RecordType.E)) {
            throw new BitsyException(BitsyErrorCodes.INTERNAL_ERROR, "Unhanded record type: " + type);
        }

        // A V or E record
        UUID id = null;
        int version = -1;
        String state = null;
        JsonToken token;

        try {
            JsonParser parser = factory.createJsonParser(json);
            
            while ((token = parser.nextToken()) != JsonToken.END_OBJECT) {
                // Find the version
                if (token == JsonToken.FIELD_NAME) {
                    if (parser.getCurrentName().equals("id")) {
                        parser.nextToken();
                        id = UUID.fromString(parser.getText());
                        continue;
                    }

                    if (parser.getCurrentName().equals("v")) {
                        parser.nextToken();
                        version = parser.getIntValue();
                        continue;
                    }

                    if (parser.getCurrentName().equals("s")) {
                        parser.nextToken();
                        state = parser.getText();

                        // No need to proceed further
                        break;
                    }
                }
            }

            if ((id == null) || (version == -1) || (state == null)) {
                throw new BitsyException(BitsyErrorCodes.INTERNAL_ERROR, "Unable to parse record '" + json + "' in file " + fileName + " at line " + lineNo);
            }

            if (state.equals("D")) {
                // Deleted -- can be ignored only on re-orgs
                return isReorg;
            } else {
                if (type == RecordType.V) {
                    VertexBean curV = store.getVertex(id);
                    if (curV == null) {
                        // Doesn't exist anymore, probably deleted later
                        return true;
                    } else if (curV.getVersion() != version) {
                        // Obsolete
                        return true;
                    } else {
                        // Good to go
                        return false;
                    }
                } else {
                    assert (type == RecordType.E);

                    EdgeBean curE = store.getEdge(id);
                    if (curE == null) {
                        // Doesn't exist anymore, probably deleted later
                        return true;
                    } else if (curE.getVersion() != version) {
                        // Obsolete
                        return true;
                    } else {
                        // Good to go
                        return false;
                    }
                }
            }
        } catch (Exception e) {
            throw new BitsyException(BitsyErrorCodes.INTERNAL_ERROR, "Possible bug in code. Error serializing line '" + json + "' in file " + fileName + " at line " + lineNo, e);
        }
    }
347579
boolean hasNext() throws DataSourceReadException {
        if (!hasNextComputed) {
            boolean stayInLoop;
            do {
                stayInLoop = false;
                /*
                 * Prior to reading the first iterator, we loop through all of
                 * the iterators to determine the minimum keyId. The minimum
                 * keyId, stored in currentMin, is used for data retrieval. The
                 * value of currentMin will be null if there is no data to
                 * retrieve.
                 */
                if (i == 0) {
                    this.currentMin = null;
                    for (DataStreamingEvent<E> elt : this.currentElt) {
                        currentMin = min(elt);
                    }
                }
                /*
                 * If there is no data to retrieve, we'll return false. If there
                 * is data to retrieve, we'll loop through the iterators and
                 * pull data for the current keyId, which is the keyId field of
                 * currentMin. If there's no data for the current keyId, this
                 * should loop through all of the iterators until their ends,
                 * and set hasNext to false.
                 */
                if (currentMin == null) {
                    this.hasNext = false;
                } else {
                    int n = this.currentElt.size();
                    for (; i < n; i++) {
                        DataStreamingEvent<E> elt = this.currentElt.get(i);
                        if (elt != null && elt.getKeyId().equals(
                                this.currentMin != null 
                                ? this.currentMin.getKeyId() : null)) {
                            this.result = elt;
                            this.nextKeyId = elt.getKeyId();
                            advance(i);
                            i++;
                            break;
                        }
                    }
                    if (this.i == n && this.result == null) {
                        this.i = 0;
                        stayInLoop = true;
                    }
                }
            } while (this.hasNext && stayInLoop);
            this.hasNextComputed = true;
        }
        return hasNext;
    }
123106
@SuppressWarnings("nls")
	private void checkNotNull(Object sourceClass, Object eventSetName, Object alistenerType, Object listenerMethodName)
	{
		if (sourceClass == null)
		{
			throw new NullPointerException(Messages.getString("beans.0C"));
		}
		if (eventSetName == null)
		{
			throw new NullPointerException(Messages.getString("beans.53"));
		}
		if (alistenerType == null)
		{
			throw new NullPointerException(Messages.getString("beans.54"));
		}
		if (listenerMethodName == null)
		{
			throw new NullPointerException(Messages.getString("beans.52"));
		}
	}
796275
@Override
  public boolean nextKeyValue()
      throws IOException {
    // If there is no next value, return false. Set current key and value to null.
    // Different Hadoop recordreaders have different behavior for calling current key and value
    // after nextKeyValue returns false.
    if (!lineReader.nextKeyValue()) {
      logger.atFine().log("All values read: record reader read %s key, value pairs.", count);
      return false;
    }
    // Get the next line.
    currentKey.set(lineReader.getCurrentKey().get());
    Text lineValue = lineReader.getCurrentValue();
    currentValue = jsonParser.parse(lineValue.toString()).getAsJsonObject();
    // Increment count of key, value pairs.
    count++;
    return true;
  }
935434
public void setToLimit(int iAreaDesc) // Set this field to the largest or smallest value
    {   // By default compare as ASCII strings
        Float tempfloat = MIN;          // Lowest value
        if (iAreaDesc == DBConstants.END_SELECT_KEY)
            tempfloat = MAX;
        this.doSetData(tempfloat, DBConstants.DONT_DISPLAY, DBConstants.SCREEN_MOVE);
    }
509688
public boolean getReadAhead()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "getReadAhead");
            SibTr.exit(tc, "getReadAhead", Boolean.valueOf(_enableReadAhead));
        }

        return _enableReadAhead;
    }
151038
private boolean goToNextDoc() throws IOException {
    if (docId == NO_MORE_DOCS) {
      return true;
    } else {
      docId = spans1.spans.nextDoc();
      if (docId == NO_MORE_DOCS) {
        return true;
      } else {
        int spans2DocId = spans2.spans.docID();
        if (spans2DocId < docId) {
          spans2DocId = spans2.spans.advance(docId);
        }
        if (docId != spans2DocId) {
          return spans1.spans.nextStartPosition() != NO_MORE_POSITIONS;
        } else if (goToNextStartPosition()) {
          return true;
        } else {
          reset();
          return false;
        }
      }
    }
  }
1140566
private boolean doRead(int amountToRead) throws IOException{
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()){
            Tr.debug(tc, "doRead, Current buffer, " + _buffer + ", reading from the TCP Channel, readLine : " + _isReadLine);
        }
        
        try {
            
            if(_tcpChannelCallback != null && !_isReadLine){
                //async read logic
                return immediateRead(amountToRead);
            } else {
                return syncRead(amountToRead);
            }
        } catch (IOException e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()){
                Tr.debug(tc, "doRead, we encountered an exception during the read : " + e);
            }
            
            if(_error != null){
                return false;
            }
            _error = e;
            throw e;
        }
    }
841725
public boolean hasNext()
		throws ArticleReaderException
	{

		try {
			if (!this.lastTaskCompleted) {
				return true;
			}

			this.keywords.reset();

			int b = read();
			while (b != -1) {

				if (keywords.check((char) b)) {
					switch (keywords.getValue()) {
					case KEY_START_PAGE:
						// taskStartPosition = bytePosition;
						return true;
					}
					keywords.reset();
				}

				b = read();
			}

			return false;

		}
		catch (Exception e) {
			throw new ArticleReaderException(e);
		}
	}
647606
public boolean hasNext() {
        if(_rs == null)
            return false;

        if(_primed)
            return true;

        try {
            _primed = _rs.next();
            return _primed;
        }
        catch(SQLException sql) {
            String msg = "An exception occurred reading from the Iterator.  Cause: " + sql;
            LOGGER.error(msg, sql);
            throw new IllegalStateException(msg, sql);
        }
    }
195229
private static boolean maybeReadTimeOut(Throwable e) {
        do {
            if (IOException.class.isInstance(e)) {
            	String message = e.getMessage().toLowerCase();
            	Matcher matcher = READ_TIME_OUT_PATTERN.matcher(message);
            	if(matcher.find()) {
            		return true;
            	}
            }
            e = e.getCause();
        } while (e != null);
        return false;
    }
1280208
@Nullable
  @ReturnsMutableCopy
  public static ICommonsMap <String, String> readMap (@Nonnull @WillClose final InputStream aIS)
  {
    final ICommonsMap <String, String> ret = new CommonsHashMap <> ();
    if (readMap (aIS, ret).isFailure ())
      return null;
    return ret;
  }
656733
private ObjectStreamClass readEnumDesc() throws IOException,
            ClassNotFoundException {
        byte tc = nextTC();
        switch (tc) {
            case TC_CLASSDESC:
                return readEnumDescInternal();
            case TC_REFERENCE:
                return (ObjectStreamClass) readCyclicReference();
            case TC_NULL:
                return null;
            default:
                throw corruptStream(tc);
        }
    }