Method that checks existence of entry in Public Suffix List database, including provided options.

@param string $entry Entry for check in Public Suffix List database

@return bool
185900
protected function suffixExists($entry)
    {
        if (!$this->suffixStore->isExists($entry)) {
            return false;
        }

        $type = $this->suffixStore->getType($entry);

        if ($this->extractionMode & static::MODE_ALLOW_ICANN && $type === Store::TYPE_ICANN) {
            return true;
        }

        return $this->extractionMode & static::MODE_ALLOW_PRIVATE && $type === Store::TYPE_PRIVATE;
    }
247231
public final boolean contains(E entry) {
        TreeEntry<E> e = getEntry(entry);
        return e != null;
    }
1325028
public function fulfillConditions($entry = null)
    {
        foreach ($this->getConditions() as $condition) {
            if ($condition->getAttribute() == MissionGameCondition::NONE) {
                continue;
            }
    
            // On passe au suivant si on a gagné
            if ($condition->getAttribute() == MissionGameCondition::VICTORY) {
                if (!$entry || !$entry->getWinner()) {
                    return false;
                }
            }
    
            // On passe au suivant si on a perdu
            if ($condition->getAttribute() == MissionGameCondition::DEFEAT) {
                if (!$entry || $entry->getWinner()) {
                    return false;
                }
            }
    
            // On passe au suivant si on a plus de n points
            if ($condition->getAttribute() == MissionGameCondition::GREATER) {
                if (!$entry || !($entry->getPoints() >= $condition->getValue())) {
                    return false;
                }
            }
    
            // On passe au suivant si on a moins de n points
            if ($condition->getAttribute() == MissionGameCondition::LESS) {
                if (!$entry || !($entry->getPoints() < $condition->getValue())) {
                    return false;
                }
            }
        }

        return true;
    }
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;
    }
269297
public function unserializeEntry($Entry)
    {
        if (!$Entry || !is_string($Entry) || !preg_match('~^a\:\d+\:\{.*\}$~', $Entry)) {
            return $Entry;
        }
        $Arr = unserialize($Entry);
        if (is_array($Arr)) {
            $this->clearExpired($Arr);
            return $Arr;
        }
        return $Entry;
    }
350316
protected function ReferenceRegistered( string $entry, array $a_obj_table_references ) : bool {
    
        // eliminate double entries
    
        foreach( $a_obj_table_references as $reference ){
        
            if ( $reference->m_table_name == $entry ) {
                    
                return true;
            }
        
        }
        
        return false;
    
    }
751138
protected function validateFactoryEntry($entry)
    {
        if (!is_string($entry) && !is_callable($entry) && !$entry instanceof FactoryInterface) {
            $type = is_object($entry) ? get_class($entry) : gettype($entry);
            $message = sprintf('Argument "entry" in "%s" must be a string, a callable or an instance '
                    . 'of "%s"; "%s" was given.', __METHOD__, FactoryInterface::class, $type);
            throw new Exception\InvalidArgumentException($message);
        }

        if (is_string($entry)) {
            if (!class_exists($entry)) {
                throw new Exception\ClassNotFoundException($entry);
            }

            if (!is_subclass_of($entry, FactoryInterface::class)) {
                $message = sprintf('Entry "%s" in "%s" is expected to be an instance of "%s".', $entry, __METHOD__, FactoryInterface::class);
                throw new Exception\InvalidArgumentException($message);
            }
        }
    }
233525
public function positionSetWeight($entry) {
    $update = $this->connection->update('site_commerce_field_data')
      ->fields(array('weight' => $entry['weight']))
      ->condition('pid', $entry['pid']);

    return $update->execute();
  }
384692
public function has(string $entryIdentifier): bool
    {
        // exists returned true or false in phpredis versions < 4.0.0, now it returns the number of keys
        $existsResult = $this->redis->exists($this->buildKey('entry:' . $entryIdentifier));
        return $existsResult === true || $existsResult > 0;
    }
173844
public function contains($url)
	{
		$url = trim($url, '/');

		foreach ($this->entries as $entry) {
			if ($entry['loc'] == $url) {
				return TRUE;
			}
		}

		return FALSE;
	}
651176
public function hasSuffix(string $suffix):bool {
        if (0 !== $this->getLength() && "" === $suffix) return false;
        return (substr($this->getValue(), -1 * strlen($suffix), strlen($suffix)) === $suffix);
    }
118089
public function characteristicsCreateGroup($entry) {
    $insert = $this->connection->insert('site_commerce_characteristics_group')->fields($entry);
    return $insert->execute();
  }
1218699
protected function _createItem( array $entry )
	{
		$item = $this->_manager->createItem();

		foreach( $entry as $name => $value )
		{
			switch( $name )
			{
				case 'locale.site.id': $item->setId( $value ); break;
				case 'locale.site.code': $item->setCode( $value ); break;
				case 'locale.site.label': $item->setLabel( $value ); break;
				case 'locale.site.status': $item->setStatus( $value ); break;
				case 'locale.site.config': $item->setConfig( (array) $value ); break;
			}
		}

		return $item;
	}
580496
protected function writeToLog($entry) {
		if ($entry[0] >= $this->logLevel) {
			trigger_error("** ".$this->getFormattedCaller()." ** {$entry[1]} **",$this->loggerTypes[$entry[0]]->getPhpErrorCode());
		}
	}
925530
public function isPlayable($subGame, $entry = null)
    {
        if (!$subGame) {
            return false;
        }
        
        $sortedPlayableGames = $this->getPlayableGames($entry);
        foreach ($sortedPlayableGames as $pgame) {
            if ($subGame->getIdentifier() === $pgame->getGame()->getIdentifier()) {
                return true;
            }
        }

        return false;
    }
982739
public function get($entry)
    {
        $value = false;

        foreach ($this->caches as $cache) {
            $value = $cache->get($entry);
            if ($value !== false) {
                return $value;
            }
        }
        return $value;
    }
1206826
function _wordwrap($entry)
    {
        if (('' != $entry) && (is_string($entry))) {
            $entry = wordwrap($entry, $this->_options['wordWrapWidth'], $this->_options['wordWrapBreak'], $this->_options['wordWrapCut']);
        }
        return $entry;
    }