@param string $entry

@return bool
432163
public function search($entry)
    {
        $data = TrimContentTransformer::trim($this->fileReader->read());

        if (in_array($entry, $data)) {
            return true;
        }

        foreach ($data as $item) {
            if (0 === strpos($entry, $item)) {
                return true;
            }
        }

        return false;
    }
558486
public function insertSliderType($entry) {
        $return_value = $this->connection->insert('site_sliders_types')
                ->fields($entry)
                ->execute();

        return $return_value;
    }
348782
public function remove($entry, $priority = false)
    {
        $unsetAnything = false;
        foreach ($this->entries as $i => $entryData) {
            if ($entry === $entryData['data'] && ($priority === false || $entryData['priority'] == $priority)) {
                unset($this->entries[$i]);
                $unsetAnything = true;
            }
        }
        if ($unsetAnything) {
            $this->sorted = false;
        }
        return $this;
    }
329191
public function get($entryIdentifier)
    {
        if (!$this->has($entryIdentifier)) {
            return false;
        }
        $result = parent::get($entryIdentifier);
        if (!\is_string($result)) {
            return false;
        }

        return \unserialize($result);
    }
497333
public function deleteEntry($Entry)
    {
        if ($this->Using === 'APCu') {
            if (apcu_delete($Entry)) {
                return $this->Modified = true;
            }
            return false;
        }
        if ($this->Using === 'Memcached' || $this->Using === 'Redis') {
            if ($this->WorkingData->delete($Entry)) {
                return $this->Modified = true;
            }
            return false;
        }
        if ($this->Using === 'PDO') {
            $PDO = $this->WorkingData->prepare(self::deleteQuery);
            if ($PDO !== false && $PDO->execute(['key' => $Entry])) {
                return ($PDO->rowCount() > 0 && $this->Modified = true);
            }
            return false;
        }
        if (is_array($this->WorkingData)) {
            if (isset($this->WorkingData[$Entry])) {
                unset($this->WorkingData[$Entry]);
                return $this->Modified = true;
            }
        }
        return false;
    }
1077009
public function has(string $entryIdentifier): bool
    {
        return $this->memcache->get($this->identifierPrefix . $entryIdentifier) !== false;
    }
281776
public function findNextEntry(Entry $entry) {
    $list = $this->findAfter($entry, 1);

    if (count($list) === 1) {
      return current($list);
    }

    return NULL;
  }
437154
protected function md2annotate($entry)
    {
        if (substr($entry, 0, 7) == '/shared') {
            return array(substr($entry, 7), 'value.shared');
        }
        else if (substr($entry, 0, 8) == '/private') {
            return array(substr($entry, 8), 'value.priv');
        }

        // @TODO: log error
    }
672451
public function add($entry)
    {
        $this->log[] = $entry;
        while (count($this->log) > $this->size) {
            array_shift($this->log);
        }
    }
1339125
private function entrySecurityCheck(MenuEntry $entry)
    {
        if (null !== $resource = $entry->getResource()) {
            return $this->aclOperator->isAccessGranted($resource, 'VIEW');
        }

        return true;
    }
580496
protected function writeToLog($entry) {
		if ($entry[0] >= $this->logLevel) {
			trigger_error("** ".$this->getFormattedCaller()." ** {$entry[1]} **",$this->loggerTypes[$entry[0]]->getPhpErrorCode());
		}
	}
1078500
public static boolean isValid(String entry) {
		boolean result = true;

		try {
			shouldRun(entry);
		} catch (Exception ex) {
			result = false;
		}
		return result;
	}
606461
public function transformEntryToNode($entry)
    {
        /*
         * An $entry looks like:
         * array(
         *      'type' => 'uri',
         *      'value' => '...'
         * )
         */

        // it seems that for instance Virtuoso returns type=literal for bnodes,
        // so we manually fix that here to avoid that problem, if other stores act
        // the same
        if (isset($entry['value'])
            && true === is_string($entry['value'])
            && false !== strpos($entry['value'], '_:')) {
            $entry['type'] = 'bnode';
        }

        $newEntry = null;

        switch ($entry['type']) {
            /*
             * Literal (language'd)
             */
            case 'literal':
                if (isset($entry['xml:lang'])) {
                    $newEntry = $this->nodeFactory->createLiteral(
                        $entry['value'],
                        'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString',
                        $entry['xml:lang']
                    );
                // if a literal was created, but with no language information, it seems to confuse
                // it when loading, therefor check if lang was explicitly given, otherwise handle it
                // as it were a normal string.
                } else {
                    $newEntry = $this->nodeFactory->createLiteral(
                        $entry['value']
                    );
                }

                break;

            /*
             * Typed-Literal
             */
            case 'typed-literal':
                $newEntry = $this->nodeFactory->createLiteral($entry['value'], $entry['datatype']);
                break;

            /*
             * NamedNode
             */
            case 'uri':
                $newEntry = $this->nodeFactory->createNamedNode($entry['value']);
                break;

            /*
             * BlankNode
             */
            case 'bnode':
                $newEntry = $this->nodeFactory->createBlankNode($entry['value']);
                break;

            default:
                throw new \Exception('Unknown type given: '.$entry['type']);
                break;
        }

        return $newEntry;
    }
517438
public function render(Entry $entry = null)
    {
        if ($entry) {
            $this->context->setEntry($entry);
        }

        /** @var \Concrete\Core\Form\Control\View $view */
        $view = $this->form->getControlView($this->context);

        $renderer = $view->getControlRenderer();
        $renderer->render();
    }
968509
public function getNextPlayableGame($entry = null)
    {
        $sortedPlayableGames = $this->getPlayableGames($entry);

        return (count($sortedPlayableGames) >= 1)?current($sortedPlayableGames)->getGame():null;
    }
154427
public function characteristicsUpdateItemIndex($entry) {
    $update = $this->connection->update('site_commerce_characteristics_item_index')
      ->fields($entry)
      ->condition('cid', $entry['cid'])
      ->condition('gid', $entry['gid']);
    return $update->execute();
  }
175380
public function updateSlide($entry) {
        $return_value = $this->connection->update('site_sliders')
                ->fields($entry)
                ->condition('sid', $entry['sid'])
                ->execute();

        return $return_value;
    }