Whether the property should be skipped.

@param PropertyMetadata $property
@param NavigatorContext $navigatorContext

@return boolean
343024
public function shouldSkipProperty(PropertyMetadata $property, NavigatorContext $navigatorContext)
    {
        return $this->versionStrategy->shouldSkipProperty($property, $navigatorContext)
                    || $this->groupStrategy->shouldSkipProperty($property, $navigatorContext);
    }
1374799
public function with($property)
    {
        if (property_exists($this, $property)) {
            return $this;
        }
        if ($this->_parent) {
            return $this->_parent->with($property);
        }

        return false;
    }
356283
private function readProperty($property, $metadata)
    {
        $reflClass = $metadata->getReflectionClass();
        
        // Skip if this property is not from this class
        if ($property->getDeclaringClass()->getName()
            != $metadata->getClassName()
        ) {
            return;
        }

        //Iterate over all annotations
        foreach($this->reader->getPropertyAnnotations($property) as $rule) {

            //Skip is its not a rule
            if ( ! $rule instanceof Rules\Rule ) continue;
            
            //Add Rule
            $metadata->addPropertyRule($property->getName(), $rule);

        }

    }
1345396
protected function hasProperty($property, ClassMetadataInfo $metadata)
    {
        if ($this->extendsClass() || (!$this->isNew && class_exists($metadata->name))) {
            // don't generate property if its already on the base class.
            $reflClass = new \ReflectionClass($this->getClassToExtend() ?: $metadata->name);
            if ($reflClass->hasProperty($property)) {
                return true;
            }
        }

        // check traits for existing property
        foreach ($this->getTraits($metadata) as $trait) {
            if ($trait->hasProperty($property)) {
                return true;
            }
        }

        return (
            isset($this->staticReflection[$metadata->name]) &&
            in_array($property, $this->staticReflection[$metadata->name]['properties'])
        );
    }
661722
public function isEmpty($property)
    {
        $value = $this->get($property);
        if ($value === null
            || (is_array($value) && empty($value)
            || (is_string($value) && empty($value)))
        ) {
            return true;
        }

        return false;
    }
437730
protected function removeDeletedReference($object, $propertyName, $propertyMetaData)
    {
        $previousValue = $this->persistenceSession->getCleanStateOfProperty($object, $propertyName);
        if ($previousValue !== null && is_array($previousValue) && isset($previousValue['value']['identifier'])
            && $this->reflectionService->getClassSchema($propertyMetaData['type'])->getModelType() === ClassSchema::MODELTYPE_ENTITY
            && $this->reflectionService->getClassSchema($propertyMetaData['type'])->isAggregateRoot() === false) {
            $object = $this->persistenceSession->getObjectByIdentifier($previousValue['value']['identifier']);
            if (!$this->visitedDuringPersistence->contains($object)) {
                $this->removeEntity($object);
            }
        }
    }
1064557
public function is($property)
    {
        if (isset($this->container[$property])) {
            return 'true' === $this->container[$property];
        }

        return null;
    }
972047
public function shouldSkipProperty(PropertyMetadata $property, Context $context): bool
    {
        foreach ($this->delegates as $delegate) {
            /** @var $delegate ExclusionStrategyInterface */
            if ($delegate->shouldSkipProperty($property, $context)) {
                return true;
            }
        }

        return false;
    }
1351570
public void ensureNavigationProperties(StructuredType entityType) throws ODataException {
        List<String> missingNavigationPropertyNames = new ArrayList<>();

        entityType.getStructuralProperties().stream().filter(property -> (property instanceof NavigationProperty)
                && !property.isNullable()).forEach(property -> {
            LOG.debug("Validating non-nullable NavigationProperty property : {}", property.getName());
            if (!links.containsKey(property.getName())) {
                missingNavigationPropertyNames.add(property.getName());
            }
        });
        if (missingNavigationPropertyNames.size() != 0) {
            StringJoiner joiner = new StringJoiner(",");
            missingNavigationPropertyNames.forEach(joiner::add);
            throw new ODataUnmarshallingException("The request does not specify the navigation links for '"
                    + joiner.toString() + ".");
        }
    }
355435
public function has($property)
    {
        foreach ((array)$property as $prop) {
            $has = $this->_parentHas($prop);

            if ($has === false) {
                $has = $this->_lazyLoad($prop);
                if ($has === null) {
                    return false;
                }
            }
        }

        return true;
    }
474656
private function update(PropertyMetadata $propertyMetadata, array $metadata): PropertyMetadata
    {
        $metadataAccessors = [
            'description' => 'get',
            'readable' => 'is',
            'writable' => 'is',
            'writableLink' => 'is',
            'readableLink' => 'is',
            'required' => 'is',
            'identifier' => 'is',
            'iri' => 'get',
            'attributes' => 'get',
        ];

        foreach ($metadataAccessors as $metadataKey => $accessorPrefix) {
            if (null === $metadata[$metadataKey]) {
                continue;
            }

            $propertyMetadata = $propertyMetadata->{'with'.ucfirst($metadataKey)}($metadata[$metadataKey]);
        }

        if ($propertyMetadata->hasSubresource()) {
            return $propertyMetadata;
        }

        return $propertyMetadata->withSubresource($this->createSubresourceMetadata($metadata['subresource'], $propertyMetadata));
    }
483310
protected function getPropertyData(PropertyMetadata $property, $propertyValue)
    {
        return $this->createProperty(
            $property->getName(),
            $this->exportManager->export($property->getType(), $propertyValue),
            $this->exportManager->getOptions($property->getType(), $this->format),
            $property->getType()
        );
    }
1278097
public function hasProperty($name, $property)
    {
        $result = false;
        if($this->has($name)) {
            $result = property_exists($this->_data[$name], $property);
        }

        return $result;
    }
317848
protected function has($property, ...$properties)
    {
        if (is_array($property)) {
            $properties = $property;
        } else {
            $properties[] = $property;
        }

        foreach ($properties as $property) {
            $property = $this->translateProperty($property);
            if (!isset($this->{$property})) {
                return false;
            }
        }

        return true;
    }
882653
private function isPropertyRequired(\ReflectionProperty $property, array $groups)
    {
        if (!$this->validator) {
            // Can not check...
            return true;
        }

        $metadata = $this->validator->getMetadataFor($property->getDeclaringClass()->getName());

        if (!$metadata instanceof ClassMetadata) {
            return true;
        }

        $propertyMetadata = $metadata->getPropertyMetadata($property->getName());

        if ($propertyMetadata) {
            // @todo: merge all metadata?
            $propertyMetadata = array_pop($propertyMetadata);

            foreach ($groups as $group) {
                $constraints = $propertyMetadata->findConstraints($group);

                foreach ($constraints as $constraint) {
                    if ($constraint instanceof NotBlank) {
                        return true;
                    }
                }
            }
        }

        return false;
    }
583397
private function completeOwningSide(AssociationMetadata $property, $targetObject)
    {
        // add this object on the owning side as well, for obvious infinite recursion
        // reasons this is only done when called on the inverse side.
        if ($property->isOwningSide()) {
            return;
        }

        $mappedByField    = $property->getMappedBy();
        $targetMetadata   = self::$entityManager->getClassMetadata($property->getTargetEntity());
        $targetProperty   = $targetMetadata->getProperty($mappedByField);
        $setterMethodName = ($targetProperty instanceof ToManyAssociationMetadata ? 'add' : 'set') . $mappedByField;

        $targetObject->{$setterMethodName}($this);
    }
171923
private function isBoomgoProperty(\ReflectionProperty $property)
    {
        $propertyName = $property->getName();
        $className = $property->getDeclaringClass()->getName();

        $annotationTag = substr_count($property->getDocComment(), $this->getLocalAnnotation());
        if (0 < $annotationTag) {
            if (1 === $annotationTag) {
                return true;
            }

            throw new \RuntimeException(sprintf('Boomgo annotation tag should occur only once for "%s->%s"', $className, $propertyName));
        }

        return false;
    }