Returns whether the next token is an opener or a word.

@return bool True if the next token is an opener, false if it is a word.

@throws GeometryIOException If the next token is not an opener or a word, or if there is no next token.
352219
public function isNextOpenerOrWord() : bool
    {
        $token = current($this->tokens);

        if ($token === false) {
            throw new GeometryIOException("Expected '(' or word but encountered end of stream");
        }

        if ($token[1] === '(') {
            return true;
        }

        if ($token[0] === static::T_WORD) {
            return false;
        }

        throw new GeometryIOException("Expected '(' or word but encountered '" . $token[1] . "'");
    }
923661
public function isAnon()
    {
        $alternatives = !$this->isDDL() && !$this->isDML() && !$this->isDCL() && !$this->isTCL() && !$this->isRead() && !$this->isWrite();

        return $this->_is_type(QueryInitializer::INIT_ANON) || $alternatives;
    }
254246
public function scNext()
    {
        $mValue = $this->next();

        return (false === $mValue and false === $this->valid()) ? self::NOT_SET_FLAG : $mValue;
    }
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;
        }
      }
    }
  }
1057277
public function isWrapping()
    {
        if (!$this->getViewConfig()->getShowGiftWrapping()) {
            return false;
        }

        if ($this->_iWrapCnt === null) {
            $this->_iWrapCnt = 0;

            $oWrap = oxNew(\OxidEsales\Eshop\Application\Model\Wrapping::class);
            $this->_iWrapCnt += $oWrap->getWrappingCount('WRAP');
            $this->_iWrapCnt += $oWrap->getWrappingCount('CARD');
        }

        return (bool) $this->_iWrapCnt;
    }
589576
private boolean isAlone( Geometry geometryN ) {
        Coordinate[] coordinates = geometryN.getCoordinates();
        if (coordinates.length > 1) {
            Coordinate first = coordinates[0];
            Coordinate last = coordinates[coordinates.length - 1];
            for( SimpleFeature line : linesList ) {
                Geometry lineGeom = (Geometry) line.getDefaultGeometry();
                int numGeometries = lineGeom.getNumGeometries();
                for( int i = 0; i < numGeometries; i++ ) {
                    Geometry subGeom = lineGeom.getGeometryN(i);
                    Coordinate[] lineCoordinates = subGeom.getCoordinates();
                    if (lineCoordinates.length < 2) {
                        continue;
                    } else {
                        Coordinate tmpFirst = lineCoordinates[0];
                        Coordinate tmpLast = lineCoordinates[lineCoordinates.length - 1];
                        if (tmpFirst.distance(first) < SAMEPOINTTHRESHOLD || tmpFirst.distance(last) < SAMEPOINTTHRESHOLD
                                || tmpLast.distance(first) < SAMEPOINTTHRESHOLD || tmpLast.distance(last) < SAMEPOINTTHRESHOLD) {
                            return false;
                        }
                    }
                }
            }
        }
        // 1 point line or no connection, mark it as alone for removal
        return true;
    }
555512
public function isAutoLiteral()
    {
        return $this->smarty->auto_literal && isset($this->value[ $this->ldel_length ]) ?
            strpos(" \n\t\r", $this->value[ $this->ldel_length ]) !== false : false;
    }
1264244
public boolean hasCardEncoding() {
    if (this.cardinalityEncoding == CardinalityEncoding.TOTALIZER)
      return this.totalizer.hasCreatedEncoding();
    else if (this.cardinalityEncoding == CardinalityEncoding.MTOTALIZER)
      return this.mtotalizer.hasCreatedEncoding();
    return false;
  }
95578
protected function isRegexpLiteral()
    {
        if (strpos("\n{;(,=:[!&|?", $this->a) !== false) {
            return true;
        }
        if ($this->a === ' ') {
            $length = strlen($this->output);
            if ($length < 2) {
                return true;
            }
            if (preg_match('/(?:case|else|in|return|typeof)$/', $this->output, $m)) {
                if ($this->output === $m[0]) {
                    return true;
                }
                $charBeforeKeyword = substr($this->output, $length - strlen($m[0]) - 1, 1);
                if (!$this->isAlphaNum($charBeforeKeyword)) {
                    return true;
                }
            }
        }
        return false;
    }
750061
public boolean isSimple() {
		if (isEmpty()) {
			return true;
		}

		if (getNumGeometries() > 1) {
			for (int n = 0; n < getNumGeometries(); n++) {
				if (!getGeometryN(n).isSimple()) {
					return false;
				}
			}
		} else {
			final Coordinate[] coords1 = getCoordinates();
			final Coordinate[] coords2 = getCoordinates();
			if (coords1.length > 1 && coords2.length > 1) {
				for (int i = 0; i < coords2.length - 1; i++) {
					for (int j = 0; j < coords1.length - 1; j++) {
						if (Mathlib.lineIntersects(coords2[i], coords2[i + 1], coords1[j], coords1[j + 1])) {
							return false;
						}
					}
				}
			} else {
				// TODO implement me
			}
		}

		return true;
	}
1228511
public function getIsSingleIterator()
	{
		/**
		 * @var XPath2NodeIterator $iter
		 */
		$iter = $this->CloneInstance();
		// $iter->named = "Original";
		$part1 = $iter->MoveNext();
		if ( $part1 )
		{
			$part2 = ! $iter->MoveNext();
			if ( $part2 ) return true;
		}

		return false;
	}
667567
private function isFunction()
    {
        $lookaheadType = $this->lexer->lookahead['type'];
        $peek          = $this->lexer->peek();

        $this->lexer->resetPeek();

        return ($lookaheadType >= Lexer::T_IDENTIFIER && $peek['type'] === Lexer::T_OPEN_PARENTHESIS);
    }
896485
public boolean isLeaf()
    {
        if ((m_strRecordName == null)
            || (m_strRecordName.equalsIgnoreCase(m_rgstrRecordHierarchy[m_rgstrRecordHierarchy.length - 1])))
                return true;    // Last line
        return false;
    }
568230
private boolean isAtEOL() {
		int next = skipLineSpace(index);
		return next >= tokens.size() || tokens.get(next).kind == NewLine;
	}
1353862
public boolean isGeometry(GeometryIndex index) {
		if (index.hasChild()) {
			return isGeometry(index.getChild());
		}
		return index.getType() == GeometryIndexType.TYPE_GEOMETRY;
	}
1114185
public boolean hasNext() {

        if (items != null) {
            if (items.hasNext()) {
                return (true);
            } else {
                items = null;
            }
        }
        Object next = findNextValidChild();
        while (next != null) {
            initializeItems(next);
            if (items != null) {
                return true;
            } else {
                next = findNextValidChild();
            }
        }
        return false;

    }
579623
public function nextTokenIsAdjacent() : bool
    {
        return $this->token === null
            || ($this->lookahead !== null
                && ($this->lookahead['position'] - $this->token['position']) === strlen($this->token['value']));
    }