/*
(non-Javadoc)

@see java.util.Iterator#hasNext()
518709
@Override
	public boolean hasNext() {
		if (null != pathsIterator && !pathsIterator.hasNext()) {
			if (null != currentBundle && null != currentBundle.getExplorerConditionalExpression())
				commentCallbackHandler.closeConditionalComment();
		}
		boolean rets = false;
		if (null != pathsIterator) {
			rets = pathsIterator.hasNext() || bundlesIterator.hasNext();
		} else {
			rets = bundlesIterator.hasNext();
		}

		return rets;
	}
409593
public boolean hasNext() throws DBException
    {
        Object record = this.next();
        if (record == null)
            return false;
        else
        {
            this.previous();        // Remember, Memory tables are FAAAAST!
            return true;
        }
    }
1180742
private boolean hasNextSafely(Iterator iterator) {
        try {
            /* Throw a ServiceConfigurationError if a provider-configuration file violates the specified format,
+            or if it names a provider class that cannot be found and instantiated, or if the result of
+            instantiating the class is not assignable to the service type, or if any other kind of exception
+            or error is thrown as the next provider is located and instantiated.
+            @see http://docs.oracle.com/javase/7/docs/api/java/util/ServiceLoader.html#iterator()
+            */
            return iterator.hasNext();
        } catch (Exception e) {
            LOGGER.error("iterator.hasNext() failed", e);
            return false;
        }
    }
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;
	}
643096
public boolean hasNext() {
		if(cachedNext != null) {
			return true;
		}
		while(cachedNext == null) {
			if(br != null) {
				// attempt to read the next line from this:
				try {
					cachedNext = br.readLine();
					if(cachedNext == null) {
						br = null;
						// next loop:
					} else {
						return true;
					}
				} catch (IOException e) {
					e.printStackTrace();
					br = null;
				}
			} else {
				// do we have more blocks to use?
				if(blockItr.hasNext()) {
					try {
						br = blockItr.next().readBlock();
					} catch (IOException e) {
						throw new RuntimeIOException();
					}
				} else {
					return false;
				}
			}
		}
		
		return false;
	}
1241291
static boolean isText(String contentType) {
        return contentType.contains("text") || contentType.contains("json")
                || contentType.contains("xml") || contentType.contains("html");
    }
687316
public boolean hasNext() {
		if(cachedNext != null) {
			return true;
		}
		if(aborted) {
			return false;
		}
		while(cachedNext == null) {
			if(!itr.hasNext()) {
				aborted = true;
				close();
				return false;
			}
			T maybeNext = itr.next();
			int ruling = filter.filterObject(maybeNext);
			if(ruling == ObjectFilter.FILTER_ABORT) {
				aborted = true;
				close();
				return false;
			} else if(ruling == ObjectFilter.FILTER_INCLUDE) {
				cachedNext = maybeNext;
			}
		}
		return true;
	}
332507
@Override
	public boolean hasNextCase() {
		// this method only returns true if dependent values are grouped
		if (!dependent) {
			return false;
		}
		for (Constraint c : constraints) {
			if (c.hasNextCase()) {
				return true;
			}
		}
		return false;
	}
243342
@Override
    public boolean hasNext() {
        if (answerIterator.hasNext()) return true;

        while (conjIterator.hasNext()) {
            answerIterator = conjunctionIterator(conjIterator.next(), tx);
            if (answerIterator.hasNext()) return true;
        }
        return false;
    }
1010409
public boolean hasNext() {
		if(done) return false;
		if(cachedNext != null) {
			return true;
		}
		while(inner.hasNext()) {
			String tmp = inner.next();
			if(tmp.startsWith(prefix)) {
				cachedNext = tmp;
				return true;
			} else if(tmp.compareTo(prefix) > 0) {
				done = true;
				return false;
			}
		}
		return false;
	}
840616
@Override
	public boolean hasNext() {

		validateState();

		if (!delegate.hasNext() && !isFinished()) {
			load(getCursorMark());
		}

		if (delegate.hasNext()) {
			return true;
		}

		return false;
	}
825318
public boolean hasNextValue() throws IOException {
        if (_parser == null) {
            return false;
        }
        JsonToken t = _parser.getCurrentToken();
        if (t == null) { // un-initialized or cleared; find next
            t = _parser.nextToken();
            // If EOF, no more
            if (t == null) {
                _parser.close();
                return false;
            }
            // And similarly if we hit END_ARRAY; except that we won't close parser
            if (t == JsonToken.END_ARRAY) {
                return false;
            }
        }
        return true;
    }
1217640
@Override
	public boolean hasNext()
	{
		try
		{
			
		
			if(this.resultSet == null)
				return false;
			else if(!this.resultSet.next())
			{
				this.dispose();
				return false;
			}
			return true;
		}
		catch (SQLException e)
		{
			dispose();

			throw new CommunicationException(e.getMessage(),e);
		}
			
	}
288007
public boolean hasNext()
    {
        if ( _matcher == null )
        {
            return false;
        }
        if ( _literal != null || _token != null )
        {
            return true;
        }
        if ( _matcher.find() )
        {
            _literal = _template.subSequence( _endPrevios, _matcher.start() ).toString();
            _token = _matcher.group();
            _endPrevios = _matcher.end();
        }
        else if ( _endPrevios < _template.length() )
        {
            // We're at the end
            _literal = _template.subSequence( _endPrevios, _template.length() ).toString();
            _endPrevios = _template.length();

            // Remove the matcher so it doesn't reset itself
            _matcher = null;
        }
        return _literal != null || _token != null;
    }
312249
@Override
	public boolean hasNext() {

		// iterate over input data until an element is created
		while (reader.hasNext() && nextElement == null) {

			try {
				final XMLEvent event = reader.nextEvent();

				switch (event.getEventType()) {

					case XMLEvent.START_DOCUMENT:
						startDocument();
						break;

					case XMLEvent.START_ELEMENT:
						startElement(event.asStartElement());
						break;

					case XMLEvent.END_DOCUMENT:
						endDocument();
						break;

					case XMLEvent.END_ELEMENT:
						endElement(event.asEndElement());
						break;

					case XMLEvent.CHARACTERS:
					case XMLEvent.CDATA:
						characters(event.asCharacters());
						break;

				}

			} catch (XMLStreamException strex) {
				logger.warn(strex.getMessage());
				break;
			}
		}

		// either an element has been created, or the stream is at its end
		return nextElement != null;
	}
331971
func (p *Paginater) HasNext() bool {
	return p.total > p.current*p.pagingNum
}
399640
public boolean hasNext()
    {
        if (scanner == null)
        {
            return false;
        }
        else
        {
            if (fetchSize != null)
            {
                if (counter < fetchSize)
                {
                    return resultsIter.hasNext();
                }
            }
            else
            {
                return resultsIter.hasNext();
            }
        }
        return false;
    }