Decides whether or not the document is reader-able without parsing the whole thing.

@return boolean Whether or not we suspect parse() will suceeed at returning an article object.
487817
function(helperIsVisible) {
    var nodes = this._getAllNodesWithTag(this._doc, ["p", "pre"]);

    // Get <div> nodes which have <br> node(s) and append them into the `nodes` variable.
    // Some articles' DOM structures might look like
    // <div>
    //   Sentences<br>
    //   <br>
    //   Sentences<br>
    // </div>
    var brNodes = this._getAllNodesWithTag(this._doc, ["div > br"]);
    if (brNodes.length) {
      var set = new Set();
      [].forEach.call(brNodes, function(node) {
        set.add(node.parentNode);
      });
      nodes = [].concat.apply(Array.from(set), nodes);
    }

    // FIXME we should have a fallback for helperIsVisible, but this is
    // problematic because of jsdom's elem.style handling - see
    // https://github.com/mozilla/readability/pull/186 for context.

    var score = 0;
    // This is a little cheeky, we use the accumulator 'score' to decide what to return from
    // this callback:
    return this._someNode(nodes, function(node) {
      if (helperIsVisible && !helperIsVisible(node))
        return false;
      var matchString = node.className + " " + node.id;

      if (this.REGEXPS.unlikelyCandidates.test(matchString) &&
          !this.REGEXPS.okMaybeItsACandidate.test(matchString)) {
        return false;
      }

      if (node.matches && node.matches("li p")) {
        return false;
      }

      var textContentLength = node.textContent.trim().length;
      if (textContentLength < 140) {
        return false;
      }

      score += Math.sqrt(textContentLength - 140);

      if (score > 20) {
        return true;
      }
      return false;
    });
  }
757488
public function isReadOnlyService()
    {
        if ($this->def->getService() === null) {
            return false;
        }

        return $this->def->getService()->getReadOnly();
    }
1013110
protected function isEnabledFeed()
    {
        if (config("{$this->configBase}.feeds.{$this->feedName}.enabled") !== true) {
            Log::warning(
                get_class($this) . ': ' .
                "The feed '{$this->feedName}' is disabled in the configuration of parser " .
                config("{$this->configBase}.parser.name") .
                ' therefore skipping processing of this e-mail'
            );
            return false;
        }
        return true;
    }
139924
public function isReadable() {
		$m = substr($this->mode, 0, 1);
		$p = strlen($this->mode) > 1 ? substr($this->mode, 1, 2) : "";
		return ($m == "r" || $p == "+");
	}
358404
public function isReadOnly()
    {
        $readOnly = false;
        $fields   = $this->getPart(Zend_Db_Table_Select::COLUMNS);
        $cols     = $this->_info[Zend_Db_Table_Abstract::COLS];

        if (!count($fields)) {
            return $readOnly;
        }

        foreach ($fields as $columnEntry) {
            $column = $columnEntry[1];
            $alias = $columnEntry[2];

            if ($alias !== null) {
                $column = $alias;
            }

            switch (true) {
                case ($column == self::SQL_WILDCARD):
                    break;

                case ($column instanceof Zend_Db_Expr):
                case (!in_array($column, $cols)):
                    $readOnly = true;
                    break 2;
            }
        }

        return $readOnly;
    }
562341
public function parse()
    {
        $this->docblockObj = new Docblock();

        $this->ignoreSpaces = false;
        $this->ignoreStar = true;
        $this->commentOpen = false;
        $this->annotationNameOpen = false;
        $this->annotationOpen = false;
        $this->summaryOpen = true;
        $this->descriptionOpen = false;

        $this->currentAnnotationStr = null;
        $this->currentAnnotationContentStr = null;

        $this->summaryStr = '';
        $this->descriptionStr = '';

        $this->currentLine = 0;
        $this->currentCharIndex = 0;
        $this->annotationLen = \strlen($this->annotation);
        $this->currentChar = $this->annotation[0];

        while (null !== $this->currentChar) {
            $currentChar = $this->currentChar;

            if ($this->ignoreSpaces && ctype_space($currentChar)) {
            } else {
                if (!$this->commentOpen) {
                    if ('/' == $currentChar) {
                        if ('*' == $this->nextCharacter() && '*' == $this->nextCharacter()) {
                            $this->commentOpen = true;
                        } else {
                            continue;
                        }
                    }
                } else {
                    if ('*' == $currentChar) {
                        $nextCharacter = $this->nextCharacter();
                        if ('/' == $nextCharacter) {
                            // stop annotation parsing on end of comment
                            $this->__tryRegisterAnnotation();
                            break;
                        } elseif ($this->ignoreStar) {
                            if (' ' == $nextCharacter) {
                                $this->nextCharacter();
                            }
                            continue;
                        }
                    }

                    if ('@' == $currentChar) {
                        $this->descriptionStr = trim($this->descriptionStr);
                        if ($this->descriptionOpen && \strlen($this->descriptionStr) > 0) {
                            $this->descriptionOpen = false;
                        }

                        $this->currentAnnotationStr = '';
                        $this->currentAnnotationContentStr = '';

                        $this->ignoreSpaces = false;
                        $this->annotationNameOpen = true;
                    } elseif ($this->annotationNameOpen || $this->annotationOpen) {
                        // stop annotation parsing on new line
                        if ("\n" == $currentChar || "\r" == $currentChar) {
                            $this->__tryRegisterAnnotation();

                            $this->ignoreSpaces = false;
                            $this->ignoreStar = true;
                        } elseif ($this->annotationNameOpen) {
                            if (ctype_space($currentChar)) {
                                $this->annotationNameOpen = false;
                                $this->annotationOpen = true;
                            } else {
                                $this->currentAnnotationStr .= $currentChar;
                            }
                        } elseif ($this->annotationOpen) {
                            $this->currentAnnotationContentStr .= $currentChar;
                        }
                    } elseif ($this->summaryOpen) {
                        // stop summary on new line
                        if (\strlen($this->summaryStr) > 0 && ("\n" == $currentChar || "\r" == $currentChar)) {
                            $this->summaryOpen = false;
                            $this->descriptionOpen = true;
                            $this->ignoreStar = true;
                        } else {
                            $this->summaryStr .= $currentChar;
                        }
                    } elseif ($this->descriptionOpen) {
                        // stop description on new line
                        if ("\n" == $currentChar || "\r" == $currentChar) {
                            $this->descriptionStr .= PHP_EOL;
                        } else {
                            $this->descriptionStr .= $currentChar;
                        }
                    }
                }
            }

            $this->nextCharacter();
        }

        $this->docblockObj->setSummary(trim($this->summaryStr));
        $this->docblockObj->setDescription(trim($this->descriptionStr));

        return $this->docblockObj;
    }
703904
public boolean parseNextLine()
    {
        if (firstTime)
        {
            firstTime = false;
            
         // Obtain an instance of an XMLReader implementation from a system property
            try {
                XMLReader parser = org.xml.sax.helpers.XMLReaderFactory.createXMLReader();
            
                // Set the ContentHandler...
                parser.setContentHandler( m_handler );
        
                   // Parse the file...
                parser.parse( new InputSource( m_reader ));
        
            } catch (IOException e) {
                e.printStackTrace();
            } catch (SAXException e) {
                e.printStackTrace();
            }
            
            m_record.close();
        }
        try {
            return m_record.hasNext();
        } catch (DBException e) {
            e.printStackTrace();
        }
        return false;
    }
834647
public function isSearchable()
    {
        if (request()->has('inline_search')) {
            $this->replace([
                'start'  => 0,
                'length' => 25,
                'search' => request()->get('inline_search')
            ]);
        }
        $search = (array) $this->get('search');
        return isset($search['value']) ? $search['value'] != '' : false;
    }
596397
public function current()
    {
        $node = $this->reader->expand();
        if ($node === false) {
            return false;
        }
        $node = $this->doc->importNode($node, true);
        if ($node === false) {
            return false;
        }
        $current = simplexml_import_dom($node);
        if ($current === false) {
            return false;
        }

        if ($this->options["asArray"]) {
            return json_decode(json_encode($current), true);
        } else {
            return $current;
        }
    }
284691
public function isReadOnly(): bool {
		return $this->statelessGuiFieldEditable === null
				|| $this->statelessGuiFieldEditable->isReadOnly($this->eiu);
	}
561827
public final boolean read() {
    Object[] curData = (Object[]) reader.read();
    if (null == curData) {
      setCurrent(null);
      setCurData(null);
      return false;
    } else {
      values.clear();
      for (int i = 0; i < curData.length; i++) {
        values.put(attrs[i], curData[i]);
      }
      return true;
    }
  }
143903
public function canParse($data)
	{
		$data = trim($data);
		$data = trim($data, '"');

		if ((substr($data, 0, 1) != '{') && (substr($data, -1, 1) != '}'))
		{
			return false;
		}

		$obj = json_decode($data);
		if (json_last_error() != JSON_ERROR_NONE)
		{
			return false;
		}

		return true;
	}
413503
protected function httpReadFirstline()
    {
        if (($l = $this->readline()) === null) {
            return null;
        }
        $e = explode(' ', $l);
        $u = isset($e[1]) ? parse_url($e[1]) : false;
        if ($u === false) {
            $this->badRequest();
            return false;
        }
        if (!isset($u['path'])) {
            $u['path'] = null;
        }
        if (isset($u['host'])) {
            $this->server['HTTP_HOST'] = $u['host'];
        }
        $srv = &$this->server;
        $srv['REQUEST_METHOD'] = $e[0];
        $srv['REQUEST_TIME'] = time();
        $srv['REQUEST_TIME_FLOAT'] = microtime(true);
        $srv['REQUEST_URI'] = $u['path'] . (isset($u['query']) ? '?' . $u['query'] : '');
        $srv['DOCUMENT_URI'] = $u['path'];
        $srv['PHP_SELF'] = $u['path'];
        $srv['QUERY_STRING'] = isset($u['query']) ? $u['query'] : null;
        $srv['SCRIPT_NAME'] = $srv['DOCUMENT_URI'] = isset($u['path']) ? $u['path'] : '/';
        $srv['SERVER_PROTOCOL'] = isset($e[2]) ? $e[2] : 'HTTP/1.1';
        $srv['REMOTE_ADDR'] = $this->addr;
        $srv['REMOTE_PORT'] = $this->port;
        return true;
    }
13507
protected function isMarkdownable()
    {
        if (!isset($this->isMarkdownable[$this->parser->tagName])) {
            // simply not markdownable

            return false;
        }
        if ($this->parser->isStartTag) {
            $return = true;
            if ($this->keepHTML) {
                $diff = array_diff(array_keys($this->parser->tagAttributes), array_keys($this->isMarkdownable[$this->parser->tagName]));
                if (!empty($diff)) {
                    // non markdownable attributes given
                    $return = false;
                }
            }
            if ($return) {
                foreach ($this->isMarkdownable[$this->parser->tagName] as $attr => $type) {
                    if ($type == 'required' && !isset($this->parser->tagAttributes[$attr])) {
                        // required markdown attribute not given
                        $return = false;
                        break;
                    }
                }
            }
            if (!$return) {
                array_push($this->notConverted, $this->parser->tagName . '::' . implode('/', $this->parser->openTags));
            }

            return $return;
        } else {
            if (!empty($this->notConverted) && end($this->notConverted) === $this->parser->tagName . '::' . implode('/', $this->parser->openTags)) {
                array_pop($this->notConverted);

                return false;
            }

            return true;
        }
    }
264282
public function isAvailable()
    {
        return $this->parser->isAvailable() &&
            version_compare(self::MINIMUM_PARSER_VERSION, $this->parser->getVersion(), '<=');
    }
561105
public function isWritable() : bool
	{
		if (! \is_resource($this->resource))
		{
			return false;
		}

		$metadata = \stream_get_meta_data($this->resource);

		return ! (false === \strpbrk($metadata['mode'], '+acwx'));
	}
75072
public function isReadable() {

		if(false !== $this -> file -> getExists()) {

			$this -> refresh();
			
			return $this -> file -> getReadable();
		}

		return false;
	}