@param string $entry

@return bool
346785
public function isEntryActive(string $entry, string $encoreField = 'encoreEntries'): bool
    {
        global $objPage;

        $parentPages = $this->modelUtil->findParentsRecursively('pid', 'tl_page', $objPage);

        $result = false;

        foreach (array_merge(is_array($parentPages) ? $parentPages : [], [$objPage]) as $i => $page) {
            $isActive = $this->isEntryActiveForPage($entry, $page, $encoreField);

            if (0 == $i || $isActive !== null) {
                $result = $isActive;
            }
        }

        return $result ? true : false;
    }
156575
public static function logEntry($entry)
  {
    $parts = explode("|", $entry, 5);
    $array = array();

    if(count($parts) != 5)
    {
      $array["timestamp"] = 0;
      $array["level"]     = TeamSpeak3::LOGLEVEL_ERROR;
      $array["channel"]   = "ParamParser";
      $array["server_id"] = "";
      $array["msg"]       = Str::factory("convert error (" . trim($entry) . ")");
      $array["msg_plain"] = $entry;
      $array["malformed"] = TRUE;
    }
    else
    {
      $array["timestamp"] = strtotime(trim($parts[0]));
      $array["level"]     = self::logLevel(trim($parts[1]));
      $array["channel"]   = trim($parts[2]);
      $array["server_id"] = trim($parts[3]);
      $array["msg"]       = Str::factory(trim($parts[4]));
      $array["msg_plain"] = $entry;
      $array["malformed"] = FALSE;
    }

    return $array;
  }
815909
public function store(CacheEntry $entry)
    {
        if (null === $entry->expirationTimestamp()) {
            $expirationTimestamp = 0; // Never expires.
        } else {
            $expirationTimestamp = $entry->expirationTimestamp();
        }

        if (!$this->getConnection()->set($entry->id(), $entry, $expirationTimestamp)) {
            return $this->failure('Failed to store data into memcache server.');
        }
    }
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();
    }
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;
    }
1137102
private function sendEntry(Entry $entry)
    {
        if ($this->batchEnabled) {
            $this->batchRunner->submitItem($this->identifier, $entry);
            return;
        }

        $this->logger->write($entry);
    }
247231
public final boolean contains(E entry) {
        TreeEntry<E> e = getEntry(entry);
        return e != null;
    }
406277
private static function isEntryOutOfScope(array $entry)
    {
        if (empty($entry['path']) && $entry['path'] !== '0') {
            return false;
        }

        if (self::$recursive) {
            return self::residesInDirectory($entry);
        }

        return self::isDirectChild($entry);
    }
60609
protected function writeMsgStr(array $entry)
    {
        $result = '';

        if (!isset($entry['msgstr'])) {
            return $result;
        }

        $isPlural = isset($entry['msgid_plural']);

        foreach ($entry['msgstr'] as $i => $value) {
            if ($entry['obsolete']) {
                $result .= "#~ ";
            }

            if ($isPlural) {
                $result .= "msgstr[$i] ";
            } else {
                if ($i == 0) {
                    $result .= 'msgstr ';
                }
            }

            $result .= $this->cleanExport($value) . "\n";
        }

        return $result;
    }
267133
public function flush($entry)
    {
        $this->manager->persist($entry);
        $this->manager->flush($entry);
    }
850486
public function getEntry($Entry)
    {
        if ($this->Using === 'APCu') {
            return $this->unserializeEntry(apcu_fetch($Entry));
        }
        if ($this->Using === 'Memcached' || $this->Using === 'Redis') {
            return $this->unserializeEntry($this->WorkingData->get($Entry));
        }
        if ($this->Using === 'PDO') {
            if ($this->clearExpiredPDO()) {
                $this->Modified = true;
            }
            $PDO = $this->WorkingData->prepare(self::getQuery);
            if ($PDO !== false && $PDO->execute(['key' => $Entry])) {
                $Data = $PDO->fetch(\PDO::FETCH_ASSOC);
                return isset($Data['Data']) ? $this->unserializeEntry($Data['Data']) : false;
            }
            return false;
        }
        if (is_array($this->WorkingData) && isset($this->WorkingData[$Entry])) {
            if (isset($this->WorkingData[$Entry]['Data']) && !empty($this->WorkingData[$Entry]['Time'])) {
                if ($this->WorkingData[$Entry]['Time'] <= 0 || $this->WorkingData[$Entry]['Time'] > time()) {
                    return $this->unserializeEntry($this->WorkingData[$Entry]['Data']);
                }
                unset($this->WorkingData[$Entry]);
                $this->Modified = true;
                return false;
            }
            return $this->unserializeEntry($this->WorkingData[$Entry]);
        }
        return false;
    }
580942
public static function transformObject(&$entry)
    {
        $filters = [
            'transformFilterAmounts',
            'transformFilterTimestamp'
        ];

        foreach ($filters as $filter) {
            if (method_exists(__CLASS__, $filter)) {
                $result = call_user_func([__CLASS__, $filter], $entry);

                if ($result) {
                    $entry = $result;
                }
            }
        }
    }
1275444
protected function writeReferences(array $entry)
    {
        $result = '';

        if (count($entry['references']) > 0) {
            foreach ($entry['references'] as $ref) {
                $result .= '#: ' . $ref . "\n";
            }
        }

        return $result;
    }
894154
private function isEntryOutOfScope(array $entry)
    {
        if (empty($entry['path']) && $entry['path'] !== '0') {
            return false;
        }

        if ($this->recursive) {
            return $this->residesInDirectory($entry);
        }

        return $this->isDirectChild($entry);
    }
752469
private function hasAncestorGuid( $entry, $ancestor )
	{
		if (
				( isset( $entry['parent'] ) && isset( $ancestor['parent'] ) && ( $entry['parent'] == $ancestor['parent'] ) ) || // The item is a sibling
				( isset( $entry['parent'] ) && ( $entry['parent'] == $ancestor['guid'] ) ) || // The item is a child
				( $entry['guid'] == $ancestor['guid'] ) // Same
		   )
		{
			return true;
		}

		if ( $entry['guid'] == 'xbrl' || $entry['parent'] == 'xbrl' )
		{
			return false; // If here and the entry guid is xbrl there can be no parent or match
		}

		$parent =& $this->getEntryForGuid( $entry['parent'] );
		if ( ! $parent ) return false;
		return $this->hasAncestorGuid( $parent, $ancestor );
	}
1040540
public function characteristicsUpdateItem($entry) {
    $update = $this->connection->update('site_commerce_characteristics_item')
      ->fields($entry)
      ->condition('cid', $entry['cid']);
    return $update->execute();
  }
18272
public function has(string $entryIdentifier): bool
    {
        $success = false;
        apcu_fetch($this->identifierPrefix . 'entry_' . $entryIdentifier, $success);
        return $success;
    }