Determine if the model has the given property.

@param  string $propertyIdent The property identifier to lookup.
@throws InvalidArgumentException If the property identifier is not a string.
@return boolean
335724
public function hasProperty($propertyIdent)
    {
        if (!is_string($propertyIdent)) {
            throw new InvalidArgumentException(
                'Property identifier must be a string.'
            );
        }

        $metadata   = $this->metadata();
        $properties = $metadata->properties();

        return isset($properties[$propertyIdent]);
    }
637688
private function hasSetMethod($reflectionClass, $propertyName): bool
    {
        $studlyProperty = $this->studly($propertyName);
        $methodName = 'set' . $studlyProperty;
        $exists = $reflectionClass->hasMethod($methodName);

        return $exists;
    }
253979
public function viewOptions($propertyIdent)
    {
        if (!$propertyIdent) {
            return [];
        }

        if ($propertyIdent instanceof PropertyInterface) {
            $propertyIdent = $propertyIdent->ident();
        }

        $options = $this->propertiesOptions();

        if (isset($options[$propertyIdent]['view_options'])) {
            return $options[$propertyIdent]['view_options'];
        } else {
            return [];
        }
    }
3337
protected function isPropertyAnnotated($propertyName)
    {
        $target = $this->getClass();
        $isAnnotated = false;

        while ($target) {

            if ($target->hasProperty($propertyName)) {
                $comment = $target->getProperty($propertyName)->getDocComment();
                if (empty($comment) === false) {
                    $isAnnotated = mb_strpos($comment, self::ANNOTATION_PROPERTY, 0, 'UTF-8') !== false;

                    if ($isAnnotated === true) {
                        break;
                    }

                }
            }

            $target = $target->getParentClass();
        }

        return $isAnnotated;
    }
461652
public function propertyExists(EntityInterface $entity, $property)
    {
        $visibleProperties = $entity->visibleProperties();

        return in_array($property, $visibleProperties);
    }
365568
public function has(string $entryIdentifier): bool
    {
        if ($entryIdentifier !== basename($entryIdentifier)) {
            throw new \InvalidArgumentException('The specified entry identifier must not contain a path segment.', 1334756878);
        }
        return file_exists($this->cacheDirectory . $entryIdentifier . $this->cacheEntryFileExtension);
    }
143437
public function setIdent($ident)
    {
        if ($ident === null) {
            $this->ident = null;
            return $this;
        }

        if (!is_string($ident)) {
            throw new InvalidArgumentException(
                sprintf(
                    '[%s] Identifier must be a string; received %s',
                    get_called_class(),
                    (is_object($ident) ? get_class($ident) : gettype($ident))
                )
            );
        }

        $this->ident = $ident;

        return $this;
    }
787692
public boolean isSet(String propName) {
        if (propName.equals("uniqueId")) {
            return isSetUniqueId();
        }
        if (propName.equals("uniqueName")) {
            return isSetUniqueName();
        }
        if (propName.equals("externalId")) {
            return isSetExternalId();
        }
        if (propName.equals("externalName")) {
            return isSetExternalName();
        }
        if (propName.equals("repositoryId")) {
            return isSetRepositoryId();
        }
        return false;
    }
288399
public function hasProperty($property)
    {
        return
            property_exists($this, $property)
            ||
            $this->hasAttribute($property)
            ||
            $this->hasData($property);
    }
1037986
public function hasIdentifier($identifier)
    {
        if(!$identifier instanceof ObjectIdentifierInterface) {
            $identifier = $this->getIdentifier($identifier);
        }

        return in_array((string) $identifier, $this->__identifier_list);
    }
312015
private function getPropertyInfo(string $propertyName, string $className, int $specVersion = 2): stdClass
    {
        foreach ($this->getProperties($className, $specVersion) as $classPropertyName => $property) {
            if ($classPropertyName === $propertyName) {
                return $property;
            }
        }

        throw new \InvalidArgumentException(sprintf('The property "%s" for the class "%s" doesn\'t exist.', $propertyName, $className));
    }
748641
private function isSearchable($propertyname) {
		foreach ($this->model->properties as $property) {
			if ( $property['name'] == $propertyname ) {
				if ( $property['searchable'] ) {
					return true;
				} else {
					return false;
				}
			}
		}
	}
800866
private function isValueSameAsPersistedValue(array $identifierParts, $model, $persistedModel): bool
    {
        foreach ($identifierParts as $identifierPart) {
            $accessor = new PropertyAccessor($identifierPart);

            if ($accessor->getValue($model) !== $accessor->getValue($persistedModel)) {
                return false;
            }
        }

        return true;
    }
369217
public function hasPropertyValue(PropertyPath $propertyPath, $fromData) : bool
    {
        try {
            $this->getPropertyValue($propertyPath, $fromData);
        }catch (InvalidArgumentException $e) {
            return false;
        }

        return true;
    }
762479
public function has(string $entryIdentifier): bool
    {
        $this->connect();

        $statementHandle = $this->databaseHandle->prepare('SELECT COUNT("identifier") FROM "' . $this->cacheTableName . '" WHERE "identifier"=? AND "context"=? AND "cache"=?' . $this->getNotExpiredStatement());
        $statementHandle->execute([$entryIdentifier, $this->context(), $this->cacheIdentifier]);
        return ($statementHandle->fetchColumn() > 0);
    }
841034
public function __isset($name)
    {
        $rc = new ReflectionClass(get_class($this));
        $privName = '_' . $name;
        if (!($rc->hasProperty($privName))) {
            require_once 'Zend/Gdata/App/InvalidArgumentException.php';
            throw new Zend_Gdata_App_InvalidArgumentException(
                    'Property ' . $name . ' does not exist');
        } else {
            if (isset($this->{$privName})) {
                if (is_array($this->{$privName})) {
                    if (count($this->{$privName}) > 0) {
                        return true;
                    } else {
                        return false;
                    }
                } else {
                    return true;
                }
            } else {
                return false;
            }
        }
    }
1351298
public function hasChangeFor($propertyName)
    {
        foreach ($this->getIterator() as $change) {
            /* @var ScalarChange $change */
            if ($change->isFor($propertyName)) {
                return true;
            }
        }

        return false;
    }