Discover if the property is NULL_ALLOWED or NULL_NOT_ALLOWED.

@param string $property property name to be retrieved.
@throws coding_exception if the requested property name is invalid.
@return bool true if the property is NULL_ALLOWED, false otherwise.
320574
public static function get_property_null($property) {

        self::fill_properties_cache();

        if (!array_key_exists($property, self::$propertiescache)) {
            throw new coding_exception('Invalid property requested: ' . $property);
        }

        return self::$propertiescache[$property]['null'];
    }
1051466
public function __isset($property)
	{
		if (array_key_exists($property, static::properties()))
		{
			return true;
		}
		elseif (static::relations($property))
		{
			return true;
		}
		elseif ($this->_get_eav($property, true))
		{
			return true;
		}
		elseif (array_key_exists($property, $this->_custom_data))
		{
			return true;
		}

		return false;
	}
513929
private function isExistingPropertySetterAvailable(string $propertyName): bool
    {
        assert($this->propertyExists($propertyName));
        if ($this->isExistingPropertyVirtual($propertyName)) {
            return !is_null($this->virtualSetters[$propertyName]);
        } else {
            return $this->realSetAvailable[$propertyName];
        }
    }
1282760
public function hasProperty($property)
    {
        if (property_exists($this, $property) || !is_null($this->data($property))) {
            return true;
        }

        return false;
    }
719144
public function get($property)
    {
        $value = null;

        if ($this->_convert) {
            $property = str_replace( "_", "-", $property );
        } else {
            $property = str_replace( "-", "_", $property );
        }

        if (array_key_exists($property, $this->_values)) {
            return $this->_values[$property];
        } else {
            return null;
        }

    }
392171
public static function property($property = null)
	{
		$property = strtolower($property);
		return array_key_exists($property, static::$properties) ? static::$properties[$property] : null;
	}
771305
public function get($property)
    {
        if ('' === $property) {
            $property = '_empty_';
        }
        if (!$this->has($property)) {
            throw new Exception\UndefinedKeyException($property);
        }

        return $this->value->$property;
    }
830246
public function __isset($property)
    {
        if (isset(static::$getterMap[static::class][$property])) {
            return true;
        }
        return $this->constraints->__isset($property);
    }
983263
protected function isPropertyEnabled(string $property, string $resourceClass): bool
    {
        if (null === $this->properties) {
            // to ensure sanity, nested properties must still be explicitly enabled
            return !$this->isPropertyNested($property, $resourceClass);
        }

        return \array_key_exists($property, $this->properties);
    }
52722
public function get($property = null)
    {
        if ($property === null || $property == '') {
            return $this->config;
        }

        $tree = explode('.', $property);
        $node = $this->config;
        foreach ($tree as $workingNode) {
            if (!array_key_exists($workingNode, $node)) {
                $actualNode = null;
                foreach ($node as $testNodeKey => $testNode) {
                    if (\URLify::filter($testNodeKey) == $workingNode) {
                        $actualNode = $testNodeKey;
                    }
                }
                if ($actualNode === null) {
                    throw new \InvalidArgumentException('The property "'.$property
                        .'" was not found. Failed while getting node "'.$workingNode.'"');
                }
                $workingNode = $actualNode;
            }
            $node = $node[$workingNode];
        }

        return $node;
    }
1130671
public function __isset($property)
    {
        if ($property = $this->getEntityDescription()->getProperty($property)) {
            $name = $property->getName();

            if ($this->_data->offsetExists($name)) {
                //if a property is one to one or many to one make sure the value
                //actually exists in the database
                $value = $this->_data->offsetGet($name);

                if ($value instanceof AnDomainEntityProxy) {
                    if ($property->isRelationship() && $property->isOneToOne()) {
                        if (!$value->getObject()) {
                            $this->getRepository()->getCommandChain()->disable();
                            $this->set($name, null);
                            $this->getRepository()->getCommandChain()->enable();

                            return false;
                        }
                    }
                }

                return true;
            }
        }

        return false;
    }
244460
protected function _propertyTypeAllowed($property, $type)
    {
        $definedType = $this->_getPropertyType($property);
        if (!$definedType) {
            return true;
        }
        if (is_object($type) && class_exists($definedType, false)) {
            return ($type instanceof $definedType);
        }
        return gettype($type) == $definedType;
    }
895797
public function __isset($property)
    {
        $name = ltrim($property, '_');
        $vars = get_object_vars($this);

        return isset($vars['_'.$name]);
    }
1157213
public function hasProperty(Node $node = null, $property) {
        if (!isset($node))
            return false;
        
        return ($node->getProperty($this->expand($property)) != null);
    }
769952
public function getRelationMappedToProperty(string $property)
    {
        InvalidArgumentException::verify(is_string($property), 'property must be a string');
        $relations = $this->getRelationMappings();

        foreach ($relations as $mapping) {
            $accessor = $mapping->getAccessor();

            if ($accessor instanceof PropertyAccessor) {
                if ($accessor->getPropertyName() === $property) {

                    return $mapping->getRelation();
                }
            }
        }

        return null;
    }
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;
    }
524247
protected function isNotNull($value)
    {
        if (is_null($value) === true || empty($value) === true) {
            throw new ExceptionFactory('DataType', [$value, 'string']);
        }

        return true;
    }